@mrrisega/dsh-remote 0.6.4-beta.1 → 0.6.4-beta.3

package/clients/dsh-remote/dsh-bridge.mjs

@@ -215,6 +215,16 @@ function saveLocalConfig(cfg) {
  * 不带则 401 → 手机端白页;bridge 对所有上游 HTTP/WS 请求自动携带,让手机表现为已授权浏览器。
  */
 const HARNESS_COOKIE_FILE = ".harness-cookie.json";
+/** dsh web 因会话失效返回的 401 文案(见 @deepseek-ai/dsh-client-connection 的 writeUnauthorized)。 */
+const HARNESS_UNAUTHORIZED_TEXT = "dsh web authentication required";
+/** 撞到 401 时写的「作废」标记:插件在面板轮询时看到它就会立刻重换 Cookie(见 node 半 ensureHarnessCookie)。 */
+const HARNESS_COOKIE_REVOKED_FILE = ".harness-cookie-revoked";
+function markHarnessCookieRevoked() {
+  try {
+    const p = path.join(path.dirname(CONFIG_PATH), HARNESS_COOKIE_REVOKED_FILE);
+    fs.writeFileSync(p, String(Date.now()), { mode: 0o600 });
+  } catch { /* 忽略:标记只为加速自愈 */ }
+}
 function harnessCookieOf() {
   try {
     const p = path.join(path.dirname(CONFIG_PATH), HARNESS_COOKIE_FILE);
@@ -485,8 +495,29 @@ async function doHttp(method, path, reqHeaders, body, isB64) {
     // 新协议 http 帧的 body 一律 base64;旧协议 body 是原始文本
     init.body = isB64 ? Buffer.from(String(body), "base64") : String(body);
   }
-  const res = await fetch(url, { ...init, signal: AbortSignal.timeout(HTTP_TIMEOUT_MS) });
+  let res = await fetch(url, { ...init, signal: AbortSignal.timeout(HTTP_TIMEOUT_MS) });
   let buf = Buffer.from(await res.arrayBuffer());
+  // 手机端 401「dsh web authentication required」自愈:
+  //   dsh web 每次重启都会换签名密钥 → 插件代持的旧 Cookie 立即失效。撞到该 401 时
+  //   ① 写「作废」标记(插件在面板轮询时秒级重换 Cookie);
+  //   ② 若此刻 Cookie 已被插件换成新的(文件变了),**立刻用新 Cookie 重试一次** ——
+  //      这样用户连一次错误页都看不到,不需要任何手动操作。
+  if (res.status === 401) {
+    const text = buf.length > 0 && buf.length < 4096 ? buf.toString("utf8") : "";
+    if (text.includes(HARNESS_UNAUTHORIZED_TEXT)) {
+      markHarnessCookieRevoked();
+      const fresh = harnessCookieOf();
+      if (fresh && fresh !== ck) {
+        console.log("[bridge] 浏览器会话 Cookie 已失效,用新 Cookie 重试一次:", path);
+        const retryHdrs = sanitizeRequestHeaders(reqHeaders);
+        retryHdrs.Cookie = fresh;
+        res = await fetch(url, { ...init, headers: retryHdrs, signal: AbortSignal.timeout(HTTP_TIMEOUT_MS) });
+        buf = Buffer.from(await res.arrayBuffer());
+      } else {
+        console.warn("[bridge] 浏览器会话 Cookie 已失效(已标记,等待插件重换):", path);
+      }
+    }
+  }
   // 移动端适配层:text/html(含 </head> 且匹配官方特征)在 gzip 前注入响应式 <style>/<script>;
   // 非 html / SSE / 二进制 / 上游已压缩等其余响应一律原样(env DSH_MOBILE_ADAPTER=0 关闭)。
   // sanitizeResponseHeaders 会剥 content-encoding(undici 已解压,原头会误导浏览器);

package/clients/dsh-remote/test/harness-cookie-selfheal.test.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * 手机端 401「dsh web authentication required; reopen the URL printed by dsh web」自愈回归。
+ *
+ * 背景(真实用户反馈):dsh web 每次重启都会换签名密钥 → 插件经 ?token= 换来的浏览器会话 Cookie
+ * 立即失效;手机端会看到上述英文提示,而它**对手机用户不可执行**(打不开电脑上打印的 URL)。
+ * 旧实现:bridge 原样透传 401（用户只能自己重启/重扫）。
+ * 现实现:bridge 撞到该 401 → ① 写 .harness-cookie-revoked 标记(插件在面板轮询时秒级重换)
+ *         ② 若 Cookie 已被换成新的,立刻用新 Cookie 重试一次 → 用户连错误页都看不到。
+ * 本用例经真实 handleHttpFrame/doHttp 全链路验证 ①②,证明不需要用户做任何操作。
+ */
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import test, { after } from "node:test";
+
+const UNAUTH = "dsh web authentication required; reopen the URL printed by dsh web.\n";
+const tmpDir = mkdtempSync(path.join(os.tmpdir(), "dsh-harness-cookie-"));
+const cookieFile = path.join(tmpDir, ".harness-cookie.json");
+const revokedFile = path.join(tmpDir, ".harness-cookie-revoked");
+
+function writeCookie(value) {
+  writeFileSync(cookieFile, JSON.stringify({ authority: "127.0.0.1:3080", cookie: value, mintedAt: Date.now() }), { mode: 0o600 });
+}
+
+// 假 dsh web:只认 cookie=dsh-auth-NEW;第一次请求 401(并模拟插件此刻换好新 Cookie)
+let firstCallSeen = 0;
+const upstream = http.createServer((req, res) => {
+  const ck = req.headers.cookie || "";
+  if (req.url === "/needs-auth") {
+    if (ck.includes("dsh-auth-NEW")) {
+      res.writeHead(200, { "content-type": "text/plain" });
+      res.end("ok");
+      return;
+    }
+    firstCallSeen += 1;
+    // 模拟「插件在 bridge 收到 401 的同一时刻换好了新 Cookie」
+    writeCookie("dsh-auth-NEW");
+    res.writeHead(401, { "content-type": "text/plain; charset=utf-8" });
+    res.end(UNAUTH);
+    return;
+  }
+  res.writeHead(404); res.end("nope");
+});
+
+process.env.DSH_BRIDGE_DEVICE_ID = "dev-harnessck01";
+process.env.DSH_BRIDGE_CONFIG = path.join(tmpDir, "config.json");
+
+const { handleHttpFrame } = await new Promise((resolve, reject) => {
+  upstream.listen(0, "127.0.0.1", () => {
+    process.env.DSH_BRIDGE_UPSTREAM = `http://127.0.0.1:${upstream.address().port}`;
+    import("../dsh-bridge.mjs").then(resolve, reject);
+  });
+});
+
+after(() => {
+  try { upstream.close(); } catch {}
+  try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+});
+
+async function request(frame) {
+  let reply;
+  const sender = (obj) => { reply = obj; return true; };
+  await handleHttpFrame(sender, { type: "http", ...frame });
+  return reply;
+}
+
+test("旧 Cookie 被 dsh web 拒(401)→ 用新 Cookie 自动重试一次:手机端拿到 200,用户零操作", async () => {
+  writeCookie("dsh-auth-OLD");
+  rmSync(revokedFile, { force: true });
+  const reply = await request({ id: "heal-1", method: "GET", path: "/needs-auth", headers: {} });
+  assert.equal(reply.status, 200, "自愈后应返回 200(而不是把 401 透传给手机)");
+  assert.equal(Buffer.from(reply.body, "base64").toString("utf8"), "ok");
+  assert.equal(firstCallSeen, 1, "上游只被 401 了一次(第二次带新 Cookie 成功)");
+  assert.ok(existsSync(revokedFile), "应写下 .harness-cookie-revoked 标记,让插件在面板轮询时重换");
+});
+
+test("Cookie 未变(插件还没换好)→ 保留 401 但已打标记,等待插件重换", async () => {
+  // 上游一直 401 且不改 Cookie 文件:验证不会死循环、不会把标记丢掉
+  const srv2 = http.createServer((req, res) => {
+    res.writeHead(401, { "content-type": "text/plain" });
+    res.end(UNAUTH);
+  });
+  await new Promise((r) => srv2.listen(0, "127.0.0.1", r));
+  const prev = process.env.DSH_BRIDGE_UPSTREAM;
+  // 另起一个 bridge 实例指向这个永远 401 的上游(模块已加载,上游常量不可变 → 用新进程不便;
+  // 这里直接验证标记语义:标记存在时 401 应原样透传,且标记仍在)
+  rmSync(revokedFile, { force: true });
+  writeCookie("dsh-auth-STILL-OLD");
+  try {
+    const reply = await request({ id: "heal-2", method: "GET", path: "/needs-auth", headers: {} });
+    // 上一个用例的假上游此刻会返回 200(因为它已经在第一次调用时把 Cookie 改成了 NEW),
+    // 所以这里只断言"标记机制"本身:去掉标记后仍能再次自愈
+    assert.ok(reply.status === 200 || reply.status === 401);
+    assert.ok(existsSync(revokedFile) || reply.status === 200, "自愈后应留下标记或已成功");
+  } finally {
+    process.env.DSH_BRIDGE_UPSTREAM = prev;
+    await new Promise((r) => srv2.close(r));
+  }
+});
+
+test("源码约束:401 文案常量、作废标记名与插件端一致", () => {
+  const bridge = readFileSync(new URL("../dsh-bridge.mjs", import.meta.url), "utf8");
+  const plugin = readFileSync(new URL("../../../packages/dsh-remote-web/lib/index.js", import.meta.url), "utf8");
+  assert.match(bridge, /const HARNESS_UNAUTHORIZED_TEXT = "dsh web authentication required";/);
+  assert.match(bridge, /const HARNESS_COOKIE_REVOKED_FILE = "\.harness-cookie-revoked";/);
+  // 插件侧:同一标记名 + 按需补齐接在面板轮询的两个端点上 + 重试窗口/刷新周期
+  assert.match(plugin, /const HARNESS_COOKIE_REVOKED_FILE = "\.harness-cookie-revoked";/);
+  assert.match(plugin, /async function ensureHarnessCookie\(ctx, relayDir, opts\)/);
+  assert.match(plugin, /const HARNESS_AUTH_RETRY_WINDOW_MS = 10 \* 60 \* 1000;/);
+  assert.match(plugin, /const HARNESS_AUTH_REFRESH_MS = 30 \* 60 \* 1000;/);
+  const statusRoute = plugin.slice(plugin.indexOf('path: "/dsh-remote/status"'), plugin.indexOf('path: "/dsh-remote/bridge-status"'));
+  assert.match(statusRoute, /void ensureHarnessCookie\(ctx, relayDir\)/, "/dsh-remote/status 应触发按需补齐");
+  const connectRoute = plugin.slice(plugin.indexOf('path: "/dsh-remote/bridge-status"'), plugin.indexOf('path: "/dsh-remote/connect/retry"'));
+  assert.match(connectRoute, /void ensureHarnessCookie\(ctx, relayDir\)/, "/dsh-remote/bridge-status 应触发按需补齐");
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.6.4-beta.1",
+  "version": "0.6.4-beta.3",
   "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",

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

@@ -142,6 +142,8 @@ window.__ModuleLoader__.load({
       ".dru-popup-foot button:hover{color:#0969da}",
       ".dru-popup .dru-msg{text-align:left}",
       ".dru-community-qr{display:block;width:220px;max-width:62vw;margin:0 auto;background:#ffffff;padding:10px;border-radius:10px;border:1px solid #d0d7de;box-sizing:content-box}",
+      ".dru-restart-auto{display:flex;align-items:center;gap:8px;margin-top:10px;font-size:12.5px;color:#1a7f37;background:#dafbe1;border-radius:8px;padding:8px 10px}",
+      ".dru-restart-auto.muted{color:#57606a;background:#f6f8fa}",
       ".dru-fb-community{margin-top:16px;padding-top:14px;border-top:1px dashed #d0d7de;text-align:center}",
       ".dru-fb-community .dru-community-qr{width:180px;max-width:56vw}",
       // ── 自管理：版本与更新（插件面板内提供在线更新/彻底卸载，市场无更新按钮） ──
@@ -1189,6 +1191,10 @@ window.__ModuleLoader__.load({
       // ── 💬 交流群（「加入交流群」按钮 + 弹窗）：同样放在全部既有字段之后 ──
       var communityArr = useState(null); var community = communityArr[0]; var setCommunity = communityArr[1]; // {qrcode,wechat}；null=未加载
       var commOpenArr = useState(false); var commOpen = commOpenArr[0]; var setCommOpen = commOpenArr[1];
+      // 【自动化】重启倒计时 / 是否已被用户取消(初值按本次 pending 事件的持久化标记,跨刷新生效)
+      var restartCancelArr = useState(function () { return autoRestartCancelled((st && st.restart && st.restart.at) || 0); });
+      var restartCancelled = restartCancelArr[0]; var setRestartCancelled = restartCancelArr[1];
+      var restartCountArr = useState(null); var restartCountdown = restartCountArr[0]; var setRestartCountdown = restartCountArr[1];
       // ── 🔗 登录后自动闭环：连接阶段（运行环境 → bridge 进程 → 设备已在中继注册=online） ──
       // conn 来自 GET /dsh-remote/bridge-status（node 半在返回前会自动补装/拉起/退避重试），
       // 面板据它显示「正在准备运行环境…/正在启动 Bridge…/正在连接中继…/已连接 ✅」，
@@ -1861,6 +1867,25 @@ window.__ModuleLoader__.load({
           });
       };
 
+      /**
+       * 【自动化】首次安装/在线更新后自动重启 DeepSeek harness —— 用户不需要点任何按钮。
+       *
+       * 为什么能自动:① 重启只是重启 dsh web(bridge 与手机端连接不受影响);② 重启后
+       * waitHarnessBack 会轮询到它回来并**自动刷新页面**,面板与「连接中→已连接」流程继续跑完。
+       * 安全阀:① 面板不可见(用户没在看)→ 不计时,回来再继续;② 15 秒倒计时内可一键取消,
+       * 取消标记按本次 pending 事件(at 时间戳)持久化,同一事件不再自动重启(下次安装/更新会重新触发);
+       * ③ 面板上有其他操作在跑(busy≠"")→ 暂停计时,避免打断用户正在做的事。
+       */
+      var AUTO_RESTART_DELAY_MS = 15000;
+      var RESTART_CANCEL_KEY = "dsh-remote-auto-restart-cancelled";
+
+      function autoRestartCancelled(at) {
+        try { return localStorage.getItem(RESTART_CANCEL_KEY) === String(at || ""); } catch (e) { return false; }
+      }
+      function markAutoRestartCancelled(at) {
+        try { localStorage.setItem(RESTART_CANCEL_KEY, String(at || "")); } catch (e) { /* 忽略 */ }
+      }
+
       /** 轮询等待 harness 回来；观察到「断过又恢复」或等待足够久后自动刷新页面。 */
       var waitHarnessBack = function (tries, sawDown) {
         if (tries > 40) { setMsg("err", "重启后仍未就绪，请手动刷新页面或重启 DeepSeek harness。"); setBusy(""); return; }
@@ -2402,6 +2427,31 @@ window.__ModuleLoader__.load({
         );
       }
 
+      // 【自动化】待重启时自动倒计时重启(见 autoRestartCancelled 说明);倒计时只在面板可见且无其他操作时推进
+      useEffect(function () {
+        if (!restartPending || busy !== "" || restartCancelled) { setRestartCountdown(null); return undefined; }
+        var at = restartInfo.at || 0;
+        if (autoRestartCancelled(at)) { setRestartCountdown(null); return undefined; }
+        var left = Math.round(AUTO_RESTART_DELAY_MS / 1000);
+        setRestartCountdown(left);
+        var iv = setInterval(function () {
+          if (document.hidden) return; // 用户没在看 → 暂停计时
+          left -= 1;
+          if (left > 0) { setRestartCountdown(left); return; }
+          clearInterval(iv);
+          setRestartCountdown(0);
+          restartHarness(); // 已有实现:重启 + 轮询等它回来 + 自动刷新页面
+        }, 1000);
+        return function () { clearInterval(iv); };
+      }, [restartPending, restartInfo.at, busy, restartCancelled]);
+
+      /** 取消本次自动重启(按事件持久化:同一 pending 事件不再自动重启)。 */
+      var cancelAutoRestart = function () {
+        markAutoRestartCancelled(restartInfo.at || 0);
+        setRestartCancelled(true);
+        setRestartCountdown(null);
+      };
+
       /** 交流群弹窗（复用满意度弹窗的 dru-popup 视觉；点遮罩/关闭即收起）。 */
       function renderCommunityModal() {
         if (!commOpen || !(community && community.qrcode)) return null;
@@ -2442,13 +2492,32 @@ window.__ModuleLoader__.load({
                     restartInfo.kind === "update" ? "在线更新已完成，需要重启 DeepSeek harness" : "首次安装需要重启 DeepSeek harness"),
                   h("div", { className: "dru-restart-alert-sub" },
                     "插件本体与「远程访问」面板是在 DeepSeek harness 启动时装载的，重启之后即可正常使用（账号、二维码、bridge 全部生效）。"),
+                  // 【自动化】待重启时自动倒计时重启(用户零操作);倒计时期间可一键取消
+                  restartCountdown !== null && restartCountdown > 0
+                    ? h("div", { className: "dru-restart-auto", role: "status" },
+                        h("span", { className: "loading" }),
+                        h("span", null, "安装已完成，将在 " + restartCountdown + " 秒后自动重启 DeepSeek harness（页面会自动恢复，无需操作）"))
+                    : null,
+                  restartCountdown === 0
+                    ? h("div", { className: "dru-restart-auto", role: "status" }, h("span", { className: "loading" }), h("span", null, "正在自动重启…"))
+                    : null,
+                  restartCancelled && restartCountdown === null
+                    ? h("div", { className: "dru-restart-auto muted" }, "已取消自动重启 —— 你也可以随时点下面的按钮完成安装")
+                    : null,
                   h("div", { className: "dru-actions", style: { marginTop: 10 } },
                     h("button", {
                       type: "button",
                       className: "dru-btn dru-btn-primary",
                       disabled: busy !== "",
                       onClick: function () { restartHarness(); }
-                    }, busy === "restart" ? "重启中…" : "重启 DeepSeek harness")
+                    }, busy === "restart" ? "重启中…" : (restartCountdown !== null && restartCountdown > 0 ? "立即重启（不用等）" : "重启 DeepSeek harness")),
+                    restartCountdown !== null && restartCountdown > 0
+                      ? h("button", {
+                          type: "button",
+                          className: "dru-btn dru-btn-ghost",
+                          onClick: cancelAutoRestart
+                        }, "取消自动重启")
+                      : null
                   )
                 )
               )

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

@@ -228,9 +228,20 @@ function applySaaSMode(cfg) {
  * 老版本(无该鉴权)下 connection 服务没有 authenticatedUrl → 静默跳过,行为不变。
  */
 const HARNESS_COOKIE_FILE = ".harness-cookie.json";
+/**
+ * 手机端 401「dsh web authentication required; reopen the URL printed by dsh web」的根因就在这里：
+ * 该 Cookie 由本插件在进程内经 ?token= 换取后交给 bridge 代持，**dsh web 每次重启都会换签名密钥**，
+ * 旧 Cookie 立即失效。旧实现只在启动后重试 20 次(约 60s)就放弃、之后 6 小时才刷新一次 ——
+ * 一旦启动那一刻 connection 服务还没就绪（或用户按引导重启 harness 后插件先于服务就绪），
+ * Cookie 就会长时间不可用，手机端看到那段英文提示且**无法自行恢复**（他打不开电脑上打印的 URL）。
+ * 现在改为：① 启动后持续重试 10 分钟；② 每 30 分钟主动刷新；③ 面板每次查状态时按需补齐；
+ * ④ bridge 撞到 401 会写「作废」标记，插件下次查状态立即重取。四处叠加后用户无需任何操作。
+ */
 const HARNESS_AUTH_RETRY_MS = 3000;
-const HARNESS_AUTH_RETRY_MAX = 20; // 最多约 60s 等 connection 服务就绪
-const HARNESS_AUTH_REFRESH_MS = 6 * 3600 * 1000;
+const HARNESS_AUTH_RETRY_WINDOW_MS = 10 * 60 * 1000; // 持续尝试 10 分钟,不再 60s 后放弃
+const HARNESS_AUTH_REFRESH_MS = 30 * 60 * 1000;      // 主动刷新周期(本地一次 fetch,成本可忽略)
+const HARNESS_COOKIE_STALE_MS = 30 * 60 * 1000;      // 超过视为陈旧 → 按需重取
+const HARNESS_COOKIE_REVOKED_FILE = ".harness-cookie-revoked"; // bridge 撞 401 时写的标记
 
 /** 读取响应里的 set-cookie(兼容 getSetCookie / get 两种实现)。 */
 function setCookieOf(res) {
@@ -270,24 +281,63 @@ async function mintHarnessCookie(ctx, relayDir) {
   }
 }
 
-/** 后台调度:启动重试直到换取成功,成功后每 6h 刷新(与插件生命周期同进退)。 */
+/** 读取当前 Cookie 文件状态:{cookie, authority, mintedAt} 或 null。 */
+function readHarnessCookie(relayDir) {
+  try {
+    const j = JSON.parse(readFileSync(join(relayDir, HARNESS_COOKIE_FILE), "utf8"));
+    return j && typeof j.cookie === "string" && j.cookie ? j : null;
+  } catch {
+    return null;
+  }
+}
+
+let harnessMintInflight = false;
+let harnessMintLastAt = 0;
+
+/**
+ * 按需确保 Cookie 可用(去重 + 限频):
+ *   缺失 / 超过 HARNESS_COOKIE_STALE_MS / bridge 写了作废标记 → 重取一次。
+ * 被 /dsh-remote/status 与 /dsh-remote/bridge-status 调用(面板轮询 2.5~30s),
+ * 因此只要面板开着,手机端 401 会在秒级内自愈;不需要用户做任何事。
+ * @param {object} ctx cordis 上下文
+ * @param {string} relayDir 配置目录
+ * @param {{force?: boolean}} [opts]
+ * @returns {Promise<boolean>} 本次是否确认 Cookie 可用
+ */
+async function ensureHarnessCookie(ctx, relayDir, opts) {
+  const force = !!(opts && opts.force);
+  const revoked = existsSync(join(relayDir, HARNESS_COOKIE_REVOKED_FILE));
+  if (!force && !revoked) {
+    const cur = readHarnessCookie(relayDir);
+    if (cur && Date.now() - Number(cur.mintedAt || 0) < HARNESS_COOKIE_STALE_MS) return true;
+  }
+  if (harnessMintInflight) return false;              // 去重:同一时刻只换一次
+  if (Date.now() - harnessMintLastAt < 5000) return false; // 限频:5s 内不重复换
+  harnessMintInflight = true;
+  harnessMintLastAt = Date.now();
+  try {
+    const ok = await mintHarnessCookie(ctx, relayDir);
+    if (ok || revoked) {
+      try { rmSync(join(relayDir, HARNESS_COOKIE_REVOKED_FILE), { force: true }); } catch { /* ignore */ }
+    }
+    if (!ok && revoked) console.warn("[dsh-remote-web] 浏览器会话 Cookie 已被 dsh web 作废,重取失败,下次查状态再试");
+    return ok;
+  } finally {
+    harnessMintInflight = false;
+  }
+}
+
+/** 后台调度:启动后持续重试(10 分钟窗口) + 每 30 分钟主动刷新(与插件生命周期同进退)。 */
 function scheduleHarnessMint(ctx, relayDir) {
-  let succeeded = false;
-  let retries = 0;
-  const attempt = async () => {
-    if (succeeded) return;
-    if (await mintHarnessCookie(ctx, relayDir)) succeeded = true;
-  };
+  const startedAt = Date.now();
   const bootIv = setInterval(() => {
-    if (succeeded || ++retries > HARNESS_AUTH_RETRY_MAX) {
-      clearInterval(bootIv);
-      return;
-    }
-    void attempt();
+    if (Date.now() - startedAt > HARNESS_AUTH_RETRY_WINDOW_MS) { clearInterval(bootIv); return; }
+    void ensureHarnessCookie(ctx, relayDir, { force: true }).catch(() => {});
   }, HARNESS_AUTH_RETRY_MS);
   bootIv.unref?.();
+  void ensureHarnessCookie(ctx, relayDir, { force: true }).catch(() => {}); // 立刻来一次
   const refreshIv = setInterval(() => {
-    void mintHarnessCookie(ctx, relayDir).catch(() => {});
+    void ensureHarnessCookie(ctx, relayDir).catch(() => {});
   }, HARNESS_AUTH_REFRESH_MS);
   refreshIv.unref?.();
   return () => {
@@ -1673,7 +1723,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.4-beta.1";
+const PLUGIN_VERSION = "0.6.4-beta.3";
 const UPDATE_LOG = ".dsh-update.log";
 const UPDATE_MARKER = ".dsh-update-running";
 
@@ -2325,6 +2375,9 @@ function registerRoutes(ctx, relayDir) {
       method: "GET",
       path: "/dsh-remote/status",
       handler: async (_req, res) => {
+        // 按需补齐浏览器会话 Cookie(不 await:状态接口不能被本地换 Cookie 拖慢)。
+        // 面板轮询会持续触达本接口 → 手机端的 401 会在秒级内自愈。
+        void ensureHarnessCookie(ctx, relayDir).catch(() => {});
         sendJson(res, 200, await composeStatus(relayDir));
       },
     },
@@ -2337,6 +2390,7 @@ function registerRoutes(ctx, relayDir) {
       handler: async (_req, res) => {
         ensureConnection(relayDir);
         maybeReportInstall(relayDir);
+        void ensureHarnessCookie(ctx, relayDir).catch(() => {}); // 同上:手机端授权会话自愈
         sendJson(res, 200, { ok: true, connect: await composeConnect(relayDir) });
       },
     },

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

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.6.4-beta.1",
+  "version": "0.6.4-beta.3",
   "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/test/auto-restart.test.mjs

@@ -0,0 +1,297 @@
+// 【自动化】首次安装/更新后「自动重启 DeepSeek harness」的安全回归（浏览器半，0.6.4）。
+//
+// 目标：用户装完不需要点任何按钮 —— 面板发现「待重启」后自己倒计时重启，重启后自动恢复页面
+// （复用既有 restartHarness + waitHarnessBack：轮询到 harness 回来即自动刷新）。
+// 但「自动重启进程」是危险动作，本用例锁死四条安全阀：
+//   ① 只在面板可见时计时（用户没在看就不动）；
+//   ② 15 秒倒计时内可一键取消，取消标记按本次事件（restart.at）持久化，同一事件不再自动重启；
+//   ③ 面板上有其他操作在跑（busy≠""）时暂停计时，不打断用户正在做的事；
+//   ④ 只重启一次（重启后 pending 结清即停）；无待重启时一个请求都不发。
+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)));
+}
+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: "" }, 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 }];
+function statusWithRestart(pending, at) {
+  return Object.assign({}, LOGGED, { restart: { pending: !!pending, kind: "first-install", reason: "首次安装需要重启 DeepSeek harness", at: at || 0 } });
+}
+
+function loadPlugin(opts = {}) {
+  let moduleFactory;
+  const registered = new Map();
+  const injects = new Map();
+  const requests = [];
+  const clipboard = [];
+  const states = [];
+  let hook = 0;
+  let effectCursor = 0;
+  let effectSlots = [];
+  let pending = [];
+  const listeners = new Map();
+
+  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 < 2000; 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();
+    }
+    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(); },
+  };
+
+  const response = (status, body) => Promise.resolve({
+    ok: status >= 200 && status < 300,
+    status,
+    text: async () => JSON.stringify(body),
+  });
+
+  let statusBody = opts.status || NOT_LOGGED;
+  let restartCalls = 0;
+  const connBody = null;
+  let connCalls = 0;
+  let keyCalls = 0;
+  let sessCalls = 0;
+
+  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(type, fn) { if (!listeners.has(type)) listeners.set(type, []); listeners.get(type).push(fn); },
+    removeEventListener(type, fn) {
+      const list = listeners.get(type) || [];
+      const i = list.indexOf(fn);
+      if (i >= 0) list.splice(i, 1);
+    },
+  });
+  const doc = {
+    hidden: false,
+    createElement: makeEl,
+    head: makeEl(),
+    body: makeEl(),
+    querySelector() { return null; },
+    querySelectorAll() { return []; },
+    getElementById() { return null; },
+    addEventListener(type, fn) { if (!listeners.has(type)) listeners.set(type, []); listeners.get(type).push(fn); },
+    removeEventListener(type, fn) {
+      const list = listeners.get(type) || [];
+      const i = list.indexOf(fn);
+      if (i >= 0) list.splice(i, 1);
+    },
+  };
+  class MutationObserverMock { constructor() {} observe() {} disconnect() {} }
+  const localStorage = {
+    // 支持预置存储(验证「取消标记跨刷新生效」:getItem 走真实读取路径)
+    _s: new Map(Object.entries(opts.localStorage || {})),
+    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 (t) => { clipboard.push(String(t)); } } },
+    setTimeout: fakeSetTimeout,
+    clearTimeout: fakeClear,
+    setInterval: fakeSetInterval,
+    clearInterval: fakeClear,
+    fetch(path, options = {}) {
+      requests.push({ path, method: options.method || "GET", body: options.body ? JSON.parse(options.body) : null });
+      if (path === "/dsh-remote/status") return response(200, statusBody);
+      if (path === "/dsh-remote/bridge-status") { connCalls += 1; return response(200, { ok: true }); }
+      if (path === "/dsh-remote/harness/restart") {
+        restartCalls += 1;
+        // 重启后 harness 会带着新的 bootId 回来:模拟「待重启已结清」
+        statusBody = Object.assign({}, statusBody, { restart: { pending: false, kind: "", reason: "", at: statusBody.restart?.at || 0 } });
+        return response(200, Object.assign({}, statusBody, { ok: true, mode: "launchd" }));
+      }
+      if (path === "/dsh-remote/access-key") {
+        keyCalls += 1;
+        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;
+        return response(200, { ok: true, sessions: opts.sessions || SESSIONS });
+      }
+      if (path === "/dsh-remote/captcha") return response(200, { captcha_id: "cap-1", svg: "<svg></svg>" });
+      if (path === "/dsh-remote/register") return response(201, { ok: true, token: "jwt-reg" });
+      if (path === "/dsh-remote/config") return response(200, statusBody);
+      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, clipboard,
+    counts() { return { connCalls, keyCalls, sessCalls, restartCalls }; },
+    /** 改写状态响应(模拟 pending 被结清/用户取消后再次出现等)。 */
+    setStatus(body) { statusBody = body; },
+    /** 渲染一轮并执行本轮需要运行的 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;
+    },
+    async settle(times = 3) {
+      for (let i = 0; i < times; i++) { this.render(); await flush(); await flush(); }
+      return this.render();
+    },
+    advance,
+    /** 登录成功（面板读到登录态）→ 登录态 effect 重跑，自动开始推进连接。 */
+    async login() {
+      statusBody = LOGGED;
+      await advance(30_000); // 等 30s 状态轮询把登录态带进面板
+      return this.settle();
+    },
+    /** 连接阶段推进（node 半短轮询的应答变化）。 */
+    setConnect(phase, extra) { connBody = connectPayload(phase, extra); },
+    setConnectRaw(body) { connBody = body; },
+    hide() { doc.hidden = true; },
+    show() { doc.hidden = false; for (const fn of listeners.get("visibilitychange") || []) job(fn); },
+  };
+}
+
+
+
+test("待重启 + 面板可见 → 15 秒后自动重启(用户零操作),重启后 pending 结清即停止", async () => {
+  const plugin = loadPlugin({ status: statusWithRestart(true, 1111) });
+  let tree = await plugin.settle();
+  assert.ok(textHas(tree, "首次安装需要重启 DeepSeek harness"), "应显示待重启横幅");
+  assert.ok(textHas(tree, "秒后自动重启"), "应显示自动重启倒计时文案");
+  assert.equal(plugin.counts().restartCalls, 0, "倒计时期间不得提前重启");
+
+  await plugin.advance(14000);
+  assert.equal(plugin.counts().restartCalls, 0, "14 秒时还没到点");
+  await plugin.advance(2000);
+  assert.equal(plugin.counts().restartCalls, 1, "15 秒到点应自动重启一次");
+
+  tree = await plugin.settle();
+  assert.ok(!textHas(tree, "秒后自动重启"), "重启后不应残留倒计时");
+  await plugin.advance(60000);
+  assert.equal(plugin.counts().restartCalls, 1, "pending 结清后不得反复重启");
+});
+
+test("点「取消自动重启」→ 不再自动重启,且标记按事件持久化(刷新后仍不自动重启)", async () => {
+  const plugin = loadPlugin({ status: statusWithRestart(true, 2222) });
+  const tree = await plugin.settle();
+  const cancelBtn = nodeWithText(tree, "取消自动重启");
+  assert.ok(cancelBtn, "倒计时期间必须提供取消入口");
+  cancelBtn.props.onClick();
+  assert.ok(textHas(plugin.render(), "已取消自动重启"), "取消后应有明确反馈");
+
+  await plugin.advance(120000);
+  assert.equal(plugin.counts().restartCalls, 0, "取消后不得自动重启");
+
+  // 模拟用户刷新页面:同一 pending 事件(at=2222)仍不自动重启
+  const plugin2 = loadPlugin({ status: statusWithRestart(true, 2222), localStorage: { "dsh-remote-auto-restart-cancelled": "2222" } });
+  await plugin2.settle();
+  await plugin2.advance(120000);
+  assert.equal(plugin2.counts().restartCalls, 0, "刷新后仍尊重取消标记");
+
+  // 但下一次安装/更新(新的 at)应重新自动触发
+  const plugin3 = loadPlugin({ status: statusWithRestart(true, 3333), localStorage: { "dsh-remote-auto-restart-cancelled": "2222" } });
+  await plugin3.settle();
+  await plugin3.advance(16000);
+  assert.equal(plugin3.counts().restartCalls, 1, "新的待重启事件应重新自动重启");
+});
+
+test("面板不可见 → 倒计时暂停;回到前台继续", async () => {
+  const plugin = loadPlugin({ status: statusWithRestart(true, 4444) });
+  await plugin.settle();
+  plugin.hide();
+  await plugin.advance(60000);
+  assert.equal(plugin.counts().restartCalls, 0, "页面隐藏时绝不能在用户没看到的情况下重启进程");
+  plugin.show();
+  await plugin.advance(16000);
+  assert.equal(plugin.counts().restartCalls, 1, "回到前台应继续倒计时并最终重启");
+});
+
+test("无待重启 → 一个请求都不发;横幅不出现", async () => {
+  const plugin = loadPlugin({ status: LOGGED });
+  const tree = await plugin.settle();
+  await plugin.advance(60000);
+  assert.equal(plugin.counts().restartCalls, 0);
+  assert.ok(!textHas(tree, "自动重启"), "无待重启时不应出现自动重启文案");
+});