dsh-remote-web 0.5.0 → 0.6.1

package/lib/index.js

@@ -1,11 +1,13 @@
-// dsh-remote-web — node half (host plugin)（2026-09 由 dsh-remote-web 更名；卸载/清理兼容旧名）
+// dsh-remote-web — node half (host plugin)（2026-09 由 dsh-remote-ui 更名 dsh-remote-web；卸载/清理兼容旧名）
 //
-// 提供 /dsh-remote/* 同源 HTTP 路由，供浏览器半的配置面板调用：
-//   - 读写 dsh-remote-open/.dsh-config.json（0600）
+// 提供 /dsh-remote/* 同源 HTTP 路由，供浏览器半的「远程访问」设置面板调用：
+//   - 读写配置目录下 .dsh-config.json（0600）
 //   - 查询/启停 bridge（launchctl，plist 缺失时自动生成，逻辑与 dsh-setup.mjs 一致）
-//   - 代理 relay API（captcha / register / login / public-config），直连、不走系统代理
+//   - 代理 relay API（captcha / register / login / public-config），直连、不走系统代理；
+//     另代理企业端一次性访问密钥 / 授权设备（/api/auth-key、/api/mobile-sessions、…/revoke、
+//     DELETE …/:id、POST …/purge，Bearer）供面板「📱 远程访问」卡使用
 //   - 自管理 self*（版本可见 / 新版检测 / 一键在线更新 / 彻底卸载）：插件市场没有更新卸载按钮，
-//     面板内即官方管理入口；更新=后台 npx @mrrisega/dsh-remote@latest（幂等补齐运行环境并重启 bridge）；
+//     面板内即官方管理入口；更新=后台 npx 按 dist-tag(默认 latest,DSH_UPDATE_TAG 可切 beta/alpha)（幂等补齐运行环境并重启 bridge）；
 //     彻底卸载=profile 插件清理（uninstallSelf）+ 运行时清理（uninstallRuntime：停 bridge 自启动 /
 //     删 plist|unit / 杀残留进程 / 清空配置目录 ~/.dsh-remote），0.4.7 起回归真正「未安装」状态
 //   - 运行时自愈：缺运行环境自动后台安装、登录后自动拉起 bridge（0.4.2 起）
@@ -15,7 +17,7 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, realpathSync, accessSync, chmodSync, openSync, closeSync, rmSync, constants as fsConstants } from "node:fs";
 import { join, dirname, sep } from "node:path";
 import { execSync, spawn } from "node:child_process";
-import { homedir, hostname, platform } from "node:os";
+import { homedir, platform } from "node:os";
 import { fileURLToPath } from "node:url";
 
 /** 本插件在 host 侧的服务依赖。 */
@@ -378,7 +380,7 @@ function ensureRuntime(relayDir) {
   try {
     mkdirSync(relayDir, { recursive: true });
     const log = join(relayDir, AUTO_INSTALL_LOG);
-    const child = spawn(npxCommand(), ["--yes", "@mrrisega/dsh-remote"], {
+    const child = spawn(npxCommand(), ["--yes", UPDATE_SPEC], {
       detached: true,
       env: spawnEnv({ npm_config_registry: "https://registry.npmjs.org" }),
       stdio: ["ignore", openSync(log, "a"), openSync(log, "a")]
@@ -610,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(), {
@@ -627,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)。 */
@@ -651,7 +812,7 @@ async function relayAccount(relayDir) {
   if (!r.ok || !r.body || !r.body.user) return null;
   const u = r.body.user;
   return {
-    phone: u.phone || "",
+    phone: maskPhone(u.phone || ""),
     plan: u.plan || "free",
     plan_source: u.plan_source || "plan",
     plan_ends_at: u.plan_ends_at ?? null,
@@ -698,8 +859,270 @@ async function relayInviteRecords(relayDir) {
   return { records: r.body.records || [], rewards: r.body.rewards || [] };
 }
 
+// ---------- 交流群二维码（运营配置，公开读取） ----------
+
+/**
+ * 交流群二维码/客服微信：企业端配置经公开配置 /api/public-config 的 community 字段下发
+ * （community.qrcode 形如 "/qr/group-qr.png"）。面板与反馈页展示「加入交流群」用。
+ *
+ * 面板跑在电脑本机 dsh web（http://127.0.0.1:3080），相对路径无法直接当 <img src>，
+ * 故这里按企业端公开约定拼成绝对地址：<api_url><qrcode>（与手机端 PWA 的 API_BASE + qr 一致）。
+ * 30s 内存缓存：面板与反馈卡都会取，避免重复打公开配置。
+ */
+const COMMUNITY_TTL_MS = 30_000;
+let communityCache = { dir: "", at: 0, data: null };
+
+async function communityInfo(relayDir) {
+  if (communityCache.data && communityCache.dir === relayDir && Date.now() - communityCache.at < COMMUNITY_TTL_MS) {
+    return communityCache.data;
+  }
+  const cfg = loadConfig(relayDir);
+  const api = (cfg.api_url || DEFAULT_API).replace(/\/+$/, "");
+  const r = await relayFetch(relayDir, "/api/public-config");
+  const b = r.ok && r.body && typeof r.body === "object" ? r.body : {};
+  const c = b.community && typeof b.community === "object" ? b.community : {};
+  const raw = String(c.qrcode || "").trim();
+  const qrcode = raw && !/^https?:/i.test(raw) ? api + (raw.startsWith("/") ? raw : `/${raw}`) : raw;
+  const data = { qrcode, wechat: String(c.wechat || "") };
+  communityCache = { dir: relayDir, at: Date.now(), data };
+  return data;
+}
+
+// ---------- 一次性访问密钥 / 已授权设备代理（E1 企业端新增 auth-key / mobile-sessions） ----------
+
+/** 从 relay 响应里尽量提取人类可读错误信息（兼容 {error:{message}} / {error:".."} / {message} / 纯文本）。 */
+function relayErrorMessage(r) {
+  const b = r && typeof r === "object" ? r.body : null;
+  if (b && typeof b === "object") {
+    if (typeof b.error === "string" && b.error) return b.error;
+    if (b.error && typeof b.error === "object") {
+      if (typeof b.error.message === "string" && b.error.message) return b.error.message;
+    }
+    if (typeof b.message === "string" && b.message) return b.message;
+  }
+  if (typeof b === "string" && b.trim()) return b.trim();
+  const st = r && r.status;
+  return st ? `企业端请求失败（HTTP ${st}）` : "企业端不可达，请稍后重试";
+}
+
+/** 未登录（无账号/自建密钥）时的统一返回文案。 */
+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 子对象里（容错）。
+ * 返回扁平对象；数组字段只取首层数组。
+ */
+function flattenRelayBody(r) {
+  const b = r && typeof r === "object" && r.body && typeof r.body === "object" ? r.body : {};
+  const d = b.data && typeof b.data === "object" ? { ...b.data, ...b } : b;
+  return d;
+}
+
+/**
+ * GET /dsh-remote/access-key → 创建一次性访问密钥（企业端 POST /api/auth-key，Bearer device-login token）。
+ * 契约容错：url 必须可用；qr_data_url 取不到时返回 null（UI 只展示链接并说明“二维码暂不可用”，不报错）。
+ */
+async function proxyCreateAccessKey(relayDir, res) {
+  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" },
+    body: JSON.stringify({}),
+  });
+  const d = flattenRelayBody(r);
+  const url = typeof d.url === "string" ? d.url.trim() : "";
+  if (!r.ok || !url) {
+    // url 不可用是硬失败（企业端契约缺陷）；错误码/状态透传给 UI 展示
+    const err = r.ok && !url ? "企业端未返回可用的访问地址（缺 url）" : relayErrorMessage(r);
+    return sendJson(res, (r && r.status) || 502, { ok: false, error: err, relayStatus: (r && r.status) || 0 });
+  }
+  return sendJson(res, 200, {
+    ok: true,
+    url,
+    key: d.key ?? null,
+    expires_at: d.expires_at ?? null,
+    ttl_ms: d.ttl_ms ?? null,
+    qr_data_url: d.qr_data_url ?? null,
+    relayStatus: (r && r.status) || 200,
+  });
+}
+
+/**
+ * GET /dsh-remote/mobile-sessions → 已授权设备列表（企业端 GET /api/mobile-sessions，Bearer）。
+ */
+async function proxyMobileSessions(relayDir, res) {
+  const token = await relayTokenOrReject(relayDir, res);
+  if (!token) return;
+  const r = await relayFetch(relayDir, "/api/mobile-sessions", {
+    method: "GET",
+    headers: { authorization: `Bearer ${token}` },
+  });
+  const d = flattenRelayBody(r);
+  const sessions = Array.isArray(d.sessions) ? d.sessions : [];
+  if (!r.ok) {
+    return sendJson(res, (r && r.status) || 502, { ok: false, error: relayErrorMessage(r), relayStatus: (r && r.status) || 0, sessions });
+  }
+  return sendJson(res, 200, { ok: true, sessions, relayStatus: (r && r.status) || 200 });
+}
+
+/**
+ * POST /dsh-remote/mobile-sessions/revoke（body {id}）→ 取消配对（企业端 POST /api/mobile-sessions/:id/revoke，Bearer）。
+ */
+async function proxyRevokeMobileSession(relayDir, req, res) {
+  const body = await readJsonBody(req);
+  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 relayTokenOrReject(relayDir, res);
+  if (!token) return;
+  const r = await relayFetch(relayDir, `/api/mobile-sessions/${encodeURIComponent(id)}/revoke`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${token}` },
+  });
+  const d = flattenRelayBody(r);
+  // 兼容两种成功形态：HTTP ok，或 body.ok === true（允许企业端 200 + ok:false 表示业务失败）
+  const ok = !!(r.ok && d.ok !== false);
+  if (!ok) {
+    return sendJson(res, (r && r.status) || 502, { ok: false, error: relayErrorMessage(r), relayStatus: (r && r.status) || 0 });
+  }
+  return sendJson(res, 200, { ok: true, relayStatus: (r && r.status) || 200 });
+}
+
+/**
+ * DELETE /dsh-remote/mobile-sessions/delete（body {id}）→ 删除本机该设备的授权记录
+ * （企业端 DELETE /api/mobile-sessions/:id，Bearer：本人整行删除并拉黑 jti）。
+ */
+async function proxyDeleteMobileSession(relayDir, req, res) {
+  const body = await readJsonBody(req);
+  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 relayTokenOrReject(relayDir, res);
+  if (!token) return;
+  const r = await relayFetch(relayDir, `/api/mobile-sessions/${encodeURIComponent(id)}`, {
+    method: "DELETE",
+    headers: { authorization: `Bearer ${token}` },
+  });
+  const d = flattenRelayBody(r);
+  const ok = !!(r.ok && d.ok !== false);
+  if (!ok) {
+    return sendJson(res, (r && r.status) || 502, { ok: false, error: relayErrorMessage(r), relayStatus: (r && r.status) || 0 });
+  }
+  return sendJson(res, 200, { ok: true, relayStatus: (r && r.status) || 200 });
+}
+
+/**
+ * POST /dsh-remote/mobile-sessions/purge → 清理本人所有已解绑（revoked）记录
+ * （企业端 POST /api/mobile-sessions/purge，Bearer）。
+ */
+async function proxyPurgeMobileSessions(relayDir, res) {
+  const token = await relayTokenOrReject(relayDir, res);
+  if (!token) return;
+  const r = await relayFetch(relayDir, "/api/mobile-sessions/purge", {
+    method: "POST",
+    headers: { authorization: `Bearer ${token}` },
+  });
+  const d = flattenRelayBody(r);
+  const ok = !!(r.ok && d.ok !== false);
+  if (!ok) {
+    return sendJson(res, (r && r.status) || 502, { ok: false, error: relayErrorMessage(r), relayStatus: (r && r.status) || 0 });
+  }
+  const removed = Number.isInteger(d.removed) ? d.removed : null;
+  const payload = { ok: true, relayStatus: (r && r.status) || 200 };
+  if (removed !== null) payload.removed = removed;
+  return sendJson(res, 200, payload);
+}
+
 // ---------- 综合状态 ----------
 
+/**
+ * 读取 bridge 写入的 E2EE 开关状态（<relayDir>/.e2ee-state.json，写入方见
+ * clients/dsh-remote/e2ee-client.mjs 的 writeE2eeStateFile：{enabled, reason, profile, epoch, caps, at}）。
+ * 归一化后只透出固定展示字段（enabled/reason/profile/epoch/caps），at 等调试字段不外泄；
+ * 文件缺失/损坏一律视为「未启用（明文回退）」——面板据此显示普通安全连接。
+ */
+export function readE2eeStateFile(relayDir) {
+  const none = () => ({ enabled: false, reason: "no_state_file", profile: "", epoch: 0, caps: [] });
+  try {
+    const f = join(relayDir, ".e2ee-state.json");
+    if (!existsSync(f)) return none();
+    const s = JSON.parse(readFileSync(f, "utf8"));
+    if (!s || typeof s !== "object") return none();
+    return {
+      enabled: s.enabled === true,
+      reason: typeof s.reason === "string" && s.reason ? s.reason : "",
+      profile: typeof s.profile === "string" ? s.profile : "",
+      epoch: Number.isInteger(s.epoch) && s.epoch >= 0 ? s.epoch : 0,
+      caps: Array.isArray(s.caps) ? s.caps.filter((c) => typeof c === "string") : [],
+    };
+  } catch {
+    return none();
+  }
+}
+
+/**
+ * 手机号脱敏(隐私审计 2026-09):面板/镜像 UI 一律不下发明文手机号。
+ * 明文只在 bridge 本机 config / 服务端账号体系内流转,浏览器侧仅见掩码。
+ */
+function maskPhone(p) {
+  const s = String(p || "");
+  return s.length >= 7 ? s.slice(0, 3) + "****" + s.slice(-4) : (s ? s.slice(0, 1) + "****" : "");
+}
+
 async function composeStatus(relayDir) {
   const cfg = loadConfig(relayDir);
   const launchd = launchdStatus();
@@ -718,7 +1141,8 @@ async function composeStatus(relayDir) {
   return {
     ok: true,
     config: {
-      phone: cfg.phone || "",
+      phone: maskPhone(cfg.phone || ""),
+      hasPhone: Boolean(cfg.phone),
       hasPassword: Boolean(cfg.password),
       deviceId: cfg.device_id || "",
       apiUrl,
@@ -734,8 +1158,11 @@ async function composeStatus(relayDir) {
       manual,
       running: launchd.running || manual.bridge.length > 0,
       bindError,
+      // E2EE 开关状态（bridge 写 .e2ee-state.json；文件缺失 = 未启用明文）：
+      // {enabled, reason, profile, epoch, caps}，供面板「📱 远程访问」卡展示加密状态。
+      e2ee: readE2eeStateFile(relayDir),
     },
-    host: hostname(),
+    // 隐私审计(2026-09):不再下发真实 hostname(移除 host 字段)——设备标识统一走 deviceId/服务端登记名
   };
 }
 
@@ -842,27 +1269,35 @@ 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.5.0";
+const PLUGIN_VERSION = "0.6.1";
 const UPDATE_LOG = ".dsh-update.log";
 const UPDATE_MARKER = ".dsh-update-running";
 
-/** 查询 npm 最新版（官方源优先，失败回退 npmmirror；纯服务端无 CORS 限制）。 */
+/**
+ * 更新通道（发布策略）：普通用户只拉稳定 dist-tag `latest`；预发(alpha/beta)由作者/内测
+ * 通过 `DSH_UPDATE_TAG=beta`（或显式版本号）拉取。迭代一律先发 beta/alpha，稳定后才升 latest。
+ */
+const UPDATE_TAG = (process.env.DSH_UPDATE_TAG || "latest").replace(/^@/, "");
+const UPDATE_SPEC = `@mrrisega/dsh-remote@${UPDATE_TAG}`;
+
+/** 查询所选通道(npm dist-tag)最新版（官方源优先，失败回退 npmmirror；纯服务端无 CORS 限制）。 */
 async function npmLatestVersion() {
   for (const reg of ["https://registry.npmjs.org/@mrrisega/dsh-remote", "https://registry.npmmirror.com/@mrrisega/dsh-remote"]) {
     try {
       const res = await fetch(reg, { signal: AbortSignal.timeout(8000) });
       if (!res.ok) continue;
       const j = await res.json();
-      if (j && j["dist-tags"] && typeof j["dist-tags"].latest === "string") return j["dist-tags"].latest;
+      const tags = j && j["dist-tags"] ? j["dist-tags"] : {};
+      if (typeof tags[UPDATE_TAG] === "string") return tags[UPDATE_TAG];
     } catch { /* 试下一个源 */ }
   }
   return "";
 }
 
-/** 以 detached 子进程执行 `npx --yes @mrrisega/dsh-remote@latest`（env 可覆盖 npm 源）。 */
+/** 以 detached 子进程执行 `npx --yes <UPDATE_SPEC>`（env 可覆盖 npm 源/更新通道）。 */
 function spawnUpdater(relayDir, extraEnv) {
   const log = join(relayDir, UPDATE_LOG);
-  return spawn(npxCommand(), ["--yes", "@mrrisega/dsh-remote@latest"], {
+  return spawn(npxCommand(), ["--yes", UPDATE_SPEC], {
     detached: true,
     cwd: homedir(),
     env: spawnEnv(extraEnv), // PATH 补 node 目录：App 最小 PATH 下也能跑 npx
@@ -871,7 +1306,7 @@ function spawnUpdater(relayDir, extraEnv) {
 }
 
 /**
- * 后台执行在线一键更新：npx @mrrisega/dsh-remote@latest（幂等自愈：补运行环境/更新 bridge/收敛 include）。
+ * 后台执行在线一键更新：npx 按 dist-tag(默认 latest)（幂等自愈：补运行环境/更新 bridge/收敛 include）。
  * 稳健性：
  *   - npx 用绝对路径 + PATH 补全解析（App 拉起的 dsh web PATH 最小化时不再 ENOENT 静默失败）；
  *   - 【官方源优先】镜像(npmmirror)滞后时会把旧版(如 0.4.4)当成最新安装，旧 pluginCmd 会把
@@ -884,7 +1319,7 @@ function runOnlineUpdate(relayDir) {
     mkdirSync(relayDir, { recursive: true });
     const marker = join(relayDir, UPDATE_MARKER);
     if (existsSync(marker)) return { ok: false, detail: "已有更新在进行中，请稍候" };
-    appendLogLine(relayDir, UPDATE_LOG, `[update] 开始在线更新 @mrrisega/dsh-remote@latest (${new Date().toISOString()})`);
+    appendLogLine(relayDir, UPDATE_LOG, `[update] 开始在线更新 ${UPDATE_SPEC} (${new Date().toISOString()})`);
 
     let retried = false;
     const clear = () => { try { rmSync(marker, { force: true }); } catch { /* ignore */ } };
@@ -1030,7 +1465,7 @@ function registerRoutes(ctx, relayDir) {
         if (rt.removedPlist) bits.push("自启动项已删除");
         if (rt.killedPids.length) bits.push(`已结束 ${rt.killedPids.length} 个残留进程`);
         if (rt.removedDir) bits.push("配置目录已清空（账号/密钥/固化运行时等）");
-        bits.push("请重启 dsh web 后完全卸载生效（本插件与远程控制将消失）；如需再次使用，在插件市场重新安装即可。");
+        bits.push("请重启 dsh web 后完全卸载生效（本插件与「远程访问」面板将消失）；如需再次使用，在插件市场重新安装即可。");
         sendJson(res, 200, {
           ok: true,
           ...prof, // removedPatch / removedDep / removedBundle / removedDir(profile 插件目录)
@@ -1086,6 +1521,54 @@ function registerRoutes(ctx, relayDir) {
         });
       },
     },
+    // 交流群二维码（设置面板「加入交流群」按钮 + 用户反馈页展示；未配置返回空串，UI 不展示入口）
+    {
+      method: "GET",
+      path: "/dsh-remote/community",
+      handler: async (_req, res) => {
+        sendJson(res, 200, { ok: true, ...(await communityInfo(relayDir)) });
+      },
+    },
+    // 一次性访问密钥（📱 远程访问卡）：GET 即创建新 key，企业端 POST /api/auth-key（Bearer）
+    {
+      method: "GET",
+      path: "/dsh-remote/access-key",
+      handler: async (_req, res) => {
+        await proxyCreateAccessKey(relayDir, res);
+      },
+    },
+    // 已授权设备列表（企业端 POST /api/mobile-sessions，Bearer）
+    {
+      method: "GET",
+      path: "/dsh-remote/mobile-sessions",
+      handler: async (_req, res) => {
+        await proxyMobileSessions(relayDir, res);
+      },
+    },
+    // 取消已授权设备配对（企业端 POST /api/mobile-sessions/:id/revoke，Bearer）
+    {
+      method: "POST",
+      path: "/dsh-remote/mobile-sessions/revoke",
+      handler: async (req, res) => {
+        await proxyRevokeMobileSession(relayDir, req, res);
+      },
+    },
+    // 删除已授权设备记录（整行删除并拉黑 jti；企业端 DELETE /api/mobile-sessions/:id，Bearer）
+    {
+      method: "DELETE",
+      path: "/dsh-remote/mobile-sessions/delete",
+      handler: async (req, res) => {
+        await proxyDeleteMobileSession(relayDir, req, res);
+      },
+    },
+    // 清理本人全部已解绑（revoked）记录（企业端 POST /api/mobile-sessions/purge，Bearer）
+    {
+      method: "POST",
+      path: "/dsh-remote/mobile-sessions/purge",
+      handler: async (_req, res) => {
+        await proxyPurgeMobileSessions(relayDir, res);
+      },
+    },
     {
       method: "POST",
       path: "/dsh-remote/config",
@@ -1116,6 +1599,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);
@@ -1156,7 +1647,11 @@ function registerRoutes(ctx, relayDir) {
       handler: async (req, res) => {
         const body = await readJsonBody(req);
         if (body.__parseError) return sendJson(res, 400, { ok: false, error: "JSON 解析失败" });
-        const phone = String(body.phone ?? "").trim();
+        let phone = String(body.phone ?? "").trim();
+        if (!phone) {
+          // 隐私审计(2026-09):账号卡修改密码不再下发明文手机号——服务端以本机账号为准
+          phone = String((loadConfig(relayDir).phone) || "").trim();
+        }
         if (!phone) return sendJson(res, 400, { ok: false, error: "手机号必填" });
         const r = await relayFetch(relayDir, "/api/sms-code", {
           method: "POST", headers: { "content-type": "application/json" },
@@ -1165,6 +1660,31 @@ function registerRoutes(ctx, relayDir) {
         sendJson(res, r.status || 502, { ok: r.ok, status: r.status, body: r.body });
       },
     },
+    {
+      method: "POST",
+      path: "/dsh-remote/password/reset",
+      handler: async (req, res) => {
+        // 公开 POST /api/password/reset（无需 Bearer）：短信验证码重置密码。
+        // 成功 → 企业端使该账号全部授权设备/会话失效（含 E2EE 派生口令）。
+        const body = await readJsonBody(req);
+        if (body.__parseError) return sendJson(res, 400, { ok: false, error: "JSON 解析失败" });
+        let phone = String(body.phone ?? "").trim();
+        if (!phone) {
+          // 隐私审计(2026-09):同上,账号卡改密不传明文手机号,服务端回填本机账号
+          phone = String((loadConfig(relayDir).phone) || "").trim();
+        }
+        const smsCode = String(body.sms_code ?? "").trim();
+        const newPassword = String(body.new_password ?? body.password ?? "");
+        if (!phone || !smsCode || !newPassword) return sendJson(res, 400, { ok: false, error: "手机号、短信验证码与新密码必填" });
+        const r = await relayFetch(relayDir, "/api/password/reset", {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ phone, sms_code: smsCode, new_password: newPassword }),
+        });
+        // 透传企业端 ok/error（成功 200 {ok:true}；失败保留 status 与错误体）
+        sendJson(res, r.status || 502, { ok: r.ok, status: r.status, body: r.body });
+      },
+    },
     {
       method: "GET",
       path: "/dsh-remote/captcha",
@@ -1257,7 +1777,7 @@ function registerRoutes(ctx, relayDir) {
           feedbackUrl: api,
           reachable,
           deviceId: cfg.device_id || "",
-          phone: cfg.phone || "",
+          phone: maskPhone(cfg.phone || ""), // 隐私:浏览器端只见掩码(代理提交时服务端另附真号)
           // 登录态（已配置账号或自建密钥）→ 节点半自动附加 JWT，免图形验证码
           auth: cfg.local_key || (cfg.phone && cfg.password) ? "account" : "anonymous"
         });