@mrrisega/dsh-remote 0.6.4-beta.8 → 0.6.4

package/dsh-setup.mjs

@@ -921,10 +921,26 @@ function writePatchAtomic(patchFile, text) {
 /**
  * 原子地写入插件 patch 激活行；写后**重新解析校验**，不合法立即回滚。
  * 返回 {ok, changed, reason?, basePatch}
+ *
+ * ⚠️ 硬约束：**本函数绝不能在插件已在 dsh.profile.bundles 时写入 patch 行**。
+ * 两个激活点同时存在时，dsh web 启动即 `duplicate loader entry id: dsh-remote-web`
+ * 并导致「plugin tree failed to load」——整个插件树加载失败（实测日志）。
+ * 因此所有 return 之前都要保证：要么只有 patch 行、要么只有 bundles 条目。
  */
 function ensurePatchActivation(patchFile, pluginLocalDir, pkgFile) {
   const original = fs.readFileSync(patchFile, "utf8");
-  // 幂等：已经是唯一激活点就什么都不做（但要确保 bundles 里没有重复激活）
+  const pkgBundles = () => {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf8"));
+      return (pkg.dsh && pkg.dsh.profile && Array.isArray(pkg.dsh.profile.bundles))
+        ? pkg.dsh.profile.bundles.filter((b) => PLUGIN_ALL_IDS.includes(b)) : [];
+    } catch { return []; }
+  };
+  // 基座就是「插件已在 bundles」→ 保持 bundles 形态（不写 patch 行），避免两个激活点并存。
+  // 这一路等价于插件市场安装形态：需要重启 dsh web 才装载。
+  if (pkgBundles().length) {
+    return { ok: false, reason: "插件已由 dsh.profile.bundles 声明（保持单一激活点，不写 patch 行）", changed: false, bundleOnly: true, basePatch: original };
+  }
   const base = validatePatchBase(original);
   if (!base.ok) return { ok: false, reason: base.reason, changed: false, basePatch: original };
   const hasOurRow = base.insertedIds.some((id) => PLUGIN_ALL_IDS.includes(id));
@@ -972,6 +988,12 @@ function ensurePatchActivation(patchFile, pluginLocalDir, pkgFile) {
     return { ok: false, reason: "写入后校验失败，已回滚", changed: false, basePatch: original };
   }
   removeBundleEntry(pkgFile); // 单一激活点：bundles 里不能再有本插件
+  // 双保险：上面那次移除若没生效（并发写 package.json / 解析失败），**回滚本次 patch 行**，
+  // 宁可退回 bundles 形态（需重启）也绝不留"两处激活"→ dsh web 启动会 duplicate id 崩掉。
+  if (pkgBundles().length) {
+    writePatchAtomic(patchFile, original);
+    return { ok: false, reason: "bundles 条目未能移除，已回滚 patch 行以免重复激活", changed: false, bundleOnly: true, basePatch: original };
+  }
   return { ok: true, changed: true, basePatch: original };
 }
 
@@ -1137,10 +1159,14 @@ function convergePluginActivation(profileDir, pkgFile, patchFile, pluginDir, pat
       console.log(`✅ 插件已就绪: ${pluginLocalDir}`);
       return { hotPatch: true, changed: r.changed, basePatch: r.basePatch };
     }
-    // patch 行写不进去(文件形态异常)→ 回退 bundles(需重启),保证功能可用
-    console.warn(`⚠️ 无法写入 patch 激活行（${r.reason}），改为 bundles 形态（需重启 dsh web 生效）`);
-    ensureBundleEntry(pkgFile);
-    console.log(`✅ 插件已就绪: ${pluginLocalDir}（bundles 形态）`);
+    // patch 行不能写(文件形态异常,或插件已由 bundles 声明)→ 回退 bundles(需重启),保证功能可用。
+    // 这条路的输出要如实说明"装完要重启一次",不能让人以为已经热加载了。
+    if (r.bundleOnly) {
+      console.log("ℹ 该插件已由 dsh.profile.bundles 声明（保持单一激活点，不重复写入 patch 行）");
+    } else {
+      console.warn(`⚠️ 无法写入 patch 激活行（${r.reason}），改为 bundles 形态（需重启 dsh web 生效）`);
+      ensureBundleEntry(pkgFile); // 回退激活点：插件仍可用，代价是必须重启一次
+    }
     return { hotPatch: false, changed: true, basePatch: patch };
   }
 

package/package.json

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

@@ -1243,6 +1243,9 @@ window.__ModuleLoader__.load({
       // 是否需要重启 DeepSeek harness（首次安装/在线更新后置顶提醒 + 底部常驻按钮）
       var restartInfo = (st && st.restart) || {};
       var restartPending = !!restartInfo.pending;
+      // kind === "refresh" = 插件文件在运行中被改写(装完/更新完),只需刷新页面;
+      // 其余情况(极为罕见)才提重启 dsh web。
+      var isRefreshOnly = restartPending && restartInfo.kind === "refresh";
       // 连接阶段（node 半下发）：轮询拿到的新鲜结果优先，其次用 /status 里带的那一份；
       // 旧版 host（响应里没有 connect 字段）→ 回退到原来的 service.running 文案（行为不变）。
       var connInfo = conn || (st && st.connect) || null;
@@ -2446,9 +2449,11 @@ window.__ModuleLoader__.load({
         );
       }
 
-      // 【自动化】待重启时自动倒计时重启(见 autoRestartCancelled 说明);倒计时只在面板可见且无其他操作时推进
+      // 【自动化】待重启时自动倒计时重启(见 autoRestartCancelled 说明);倒计时只在面板可见且无其他操作时推进。
+      // ⚠️ isRefreshOnly(插件更新后只需刷新)时**不**自动重启:刷新是零风险动作,重启 dsh web 会打断
+      // 用户正在进行的会话,不能替他做这个决定 —— 让他点「刷新页面」即可。
       useEffect(function () {
-        if (!restartPending || busy !== "" || restartCancelled) { setRestartCountdown(null); return undefined; }
+        if (!restartPending || isRefreshOnly || 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);
@@ -2462,7 +2467,7 @@ window.__ModuleLoader__.load({
           restartHarness(); // 已有实现:重启 + 轮询等它回来 + 自动刷新页面
         }, 1000);
         return function () { clearInterval(iv); };
-      }, [restartPending, restartInfo.at, busy, restartCancelled]);
+      }, [restartPending, isRefreshOnly, restartInfo.at, busy, restartCancelled]);
 
       /** 取消本次自动重启(按事件持久化:同一 pending 事件不再自动重启)。 */
       var cancelAutoRestart = function () {
@@ -2508,9 +2513,13 @@ window.__ModuleLoader__.load({
                 h("span", { className: "dru-restart-alert-icon" }, "🔔"),
                 h("div", { style: { flex: "1" } },
                   h("div", { className: "dru-restart-alert-title" },
-                    restartInfo.kind === "update" ? "在线更新已完成，需要重启 DeepSeek harness" : "首次安装需要重启 DeepSeek harness"),
+                    // 插件已改为 patch 热加载:装插件/在线更新都不再需要重启 harness,
+                    // 唯一要用户动一下的情形是"插件文件在运行中被改写"→ 刷新页面即可。
+                    isRefreshOnly ? "插件已更新，刷新页面即可生效" : "需要重启 dsh web 才能载入新插件"),
                   h("div", { className: "dru-restart-alert-sub" },
-                    "插件本体与「远程访问」面板是在 DeepSeek harness 启动时装载的，重启之后即可正常使用（账号、二维码、bridge 全部生效）。"),
+                    isRefreshOnly
+                      ? "刚装好/刚更新的插件已在磁盘上，浏览器里的面板还是旧版本。刷新一下这个页面即可（手机端连接与已登录状态都不受影响）。"
+                      : "当前运行中的 dsh web 里还没有载入这个插件。先刷新页面；如果刷新后仍然看不到面板，再重启一次 dsh web。"),
                   // 【自动化】待重启时自动倒计时重启(用户零操作);倒计时期间可一键取消
                   restartCountdown !== null && restartCountdown > 0
                     ? h("div", { className: "dru-restart-auto", role: "status" },
@@ -2524,12 +2533,19 @@ window.__ModuleLoader__.load({
                     ? h("div", { className: "dru-restart-auto muted" }, "已取消自动重启 —— 你也可以随时点下面的按钮完成安装")
                     : null,
                   h("div", { className: "dru-actions", style: { marginTop: 10 } },
+                    isRefreshOnly
+                      ? h("button", {
+                          type: "button",
+                          className: "dru-btn dru-btn-primary",
+                          onClick: function () { try { location.reload(); } catch (e) { /* 忽略 */ } }
+                        }, "刷新页面")
+                      : null,
                     h("button", {
                       type: "button",
-                      className: "dru-btn dru-btn-primary",
+                      className: "dru-btn " + (isRefreshOnly ? "dru-btn-ghost" : "dru-btn-primary"),
                       disabled: busy !== "",
                       onClick: function () { restartHarness(); }
-                    }, busy === "restart" ? "重启中…" : (restartCountdown !== null && restartCountdown > 0 ? "立即重启（不用等）" : "重启 DeepSeek harness")),
+                    }, busy === "restart" ? "重启中…" : (restartCountdown !== null && restartCountdown > 0 ? "立即重启（不用等）" : "重启 dsh web")),
                     restartCountdown !== null && restartCountdown > 0
                       ? h("button", {
                           type: "button",
@@ -2545,13 +2561,13 @@ window.__ModuleLoader__.load({
         ),
         // 常驻入口最底部：「重启 DeepSeek harness」按钮始终可达（首次安装/更新/排查都用它）
         h("div", { className: "dru-restart-foot" },
-          h("div", { className: "dru-hint" }, "重启 DeepSeek harness：插件与面板在 harness 启动时装载，首次安装或在线更新后重启即可生效；仅重启 dsh web，不影响 bridge 与手机端连接。"),
+          h("div", { className: "dru-hint" }, "重启 dsh web：仅在「刷新页面后仍看不到面板」时才需要。日常安装/更新插件已自动热加载，装完刷新页面即可；重启只影响 dsh web 本身，不影响 bridge 与手机端连接。"),
           h("button", {
             type: "button",
             className: "dru-btn " + (restartPending ? "dru-btn-primary" : "dru-btn-ghost"),
             disabled: busy !== "",
             onClick: function () { restartHarness(); }
-          }, busy === "restart" ? "重启中…" : "🔄 重启 DeepSeek harness")
+          }, busy === "restart" ? "重启中…" : "🔄 重启 dsh web")
         ),
         renderCommunityModal()
       );

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

@@ -677,8 +677,11 @@ function scheduleRuntime(relayDir) {
       telemetryRuntimeProbe(relayDir); // 匿名遥测：环境刚补齐 → runtime_ready（每进程一次）
       if (awaitingRestartHint) {
         awaitingRestartHint = false;
-        // 首次安装：运行环境（bridge + 自启动）刚在本进程内补齐 → 提示重启，重启后即完全可用
-        markRestartPending(relayDir, "first-install", "首次安装需要重启 DeepSeek harness");
+        // 运行环境刚在本进程内补齐 —— **不需要重启 harness**：
+        //   · bridge 是独立 launchd 进程，补齐后自愈调度会直接把它拉起；
+        //   · 插件本体走 patch 热加载，装完即生效。
+        // 以前这里会 markRestartPending("first-install") 弹出"需要重启 DeepSeek harness"横幅，
+        // 在热加载落地后已经变成纯粹的误导（用户实测反馈），故移除。
       }
       const cfg = loadConfig(relayDir);
       const hasAcct = Boolean((cfg.phone || cfg.email) && cfg.password) || Boolean(cfg.local_key);
@@ -849,7 +852,10 @@ function writeRestartState(relayDir, state) {
   } catch { /* 写盘失败不致命：面板退化为不提示 */ }
 }
 
-/** 标记「需要重启 DeepSeek harness」。kind: first-install(首次安装) | update(在线更新)。 */
+/**
+ * 标记「需要用户动一下」的状态。kind = refresh(插件被运行时改写,刷新页面即可)。
+ * 历史 kind(first-install / update)已废弃:热加载落地后,装插件与在线更新都不再需要重启 harness。
+ */
 function markRestartPending(relayDir, kind, reason) {
   const cur = readRestartState(relayDir);
   if (cur.pending && cur.kind === kind) return cur; // 幂等：同一原因不反复重写
@@ -881,7 +887,15 @@ function pluginInstalledAfterBoot() {
     const pkgFile = join(dirname(dirname(here)), "package.json");
     const mtimeMs = statSync(pkgFile).mtimeMs;
     const bootMs = Date.now() - process.uptime() * 1000;
-    return mtimeMs > bootMs + 2000;
+    if (!(mtimeMs > bootMs + 2000)) return false;
+    // ⚠️ 只看时间戳会**误报**:安装器补装/在线更新会把同样的文件重写一遍(哪怕是同一个版本),
+    // 时间戳变新 → 被当成"有新插件要装载" → 弹出"需要重启/刷新"横幅(用户实测踩到:
+    // 自愈补装把 profile 副本重写了一次,运行中的旧代码就写下了"需要重启")。
+    // 真正该提示用户的只有一件事:**磁盘上的插件版本与本进程装载的版本不同**。
+    // 版本相同 → 运行中的代码就是目标版本,什么都不用做。
+    const diskVersion = String(JSON.parse(readFileSync(pkgFile, "utf8")).version || "");
+    const runningVersion = String(PLUGIN_VERSION || "");
+    return Boolean(diskVersion && runningVersion && diskVersion !== runningVersion);
   } catch { return false; }
 }
 
@@ -1739,7 +1753,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.8";
+const PLUGIN_VERSION = "0.6.4";
 const UPDATE_LOG = ".dsh-update.log";
 const UPDATE_MARKER = ".dsh-update-running";
 
@@ -1764,6 +1778,44 @@ async function npmLatestVersion() {
   return "";
 }
 
+/**
+ * 语义化版本比较（只处理本仓库用到的形态：`X.Y.Z` 与 `X.Y.Z-<pre>.<n>`）。
+ * 为什么需要它：面板判断"有没有新版本"不能只用 `latest !== current` ——
+ * 预设版之间（beta.10 → beta.11）无法比较大小，而且预设版在 semver 里**低于**同号正式版
+ * （0.6.4 < 0.6.4），朴素不等判断会把"已经装了预设版"误判成落后。
+ * @returns {number} a>b → 1；a<b → -1；相等 → 0
+ */
+function compareVersions(a, b) {
+  const parse = (v) => {
+    const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(String(v || "").trim());
+    if (!m) return null;
+    return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ? m[4].split(".") : null };
+  };
+  const x = parse(a);
+  const y = parse(b);
+  if (!x || !y) return null; // 无法解析 → 交给调用方保守处理
+  for (let i = 0; i < 3; i += 1) {
+    if (x.nums[i] !== y.nums[i]) return x.nums[i] > y.nums[i] ? 1 : -1;
+  }
+  if (!x.pre && !y.pre) return 0;
+  if (!x.pre) return 1;   // 有预设版 < 无预设版（semver §11）
+  if (!y.pre) return -1;
+  const len = Math.max(x.pre.length, y.pre.length);
+  for (let i = 0; i < len; i += 1) {
+    const p1 = x.pre[i];
+    const p2 = y.pre[i];
+    if (p1 === undefined) return -1;
+    if (p2 === undefined) return 1;
+    const n1 = /^\d+$/.test(p1) ? Number(p1) : null;
+    const n2 = /^\d+$/.test(p2) ? Number(p2) : null;
+    if (n1 !== null && n2 !== null) { if (n1 !== n2) return n1 > n2 ? 1 : -1; continue; }
+    if (n1 !== null) return -1; // 数字标识符 < 字母标识符
+    if (n2 !== null) return 1;
+    if (p1 !== p2) return p1 > p2 ? 1 : -1;
+  }
+  return 0;
+}
+
 /** 以 detached 子进程执行 `npx --yes <UPDATE_SPEC>`（env 可覆盖 npm 源/更新通道）。 */
 function spawnUpdater(relayDir, extraEnv) {
   const log = join(relayDir, UPDATE_LOG);
@@ -1809,9 +1861,12 @@ function runOnlineUpdate(relayDir) {
         }
         appendLogLine(relayDir, UPDATE_LOG, `[update] npx 退出 code=${code ?? "?"}（${retried ? "默认源" : "官方源"}）`);
         clear();
-        // 在线更新改写了插件/运行环境文件 → 必须重启 DeepSeek harness 才装载新版本
-        if (code === 0) markRestartPending(relayDir, "update", "已在线更新，需要重启 DeepSeek harness 生效");
-        else telemetryRecord(relayDir, "update_failed", { fail_code: telemetryFailCodeFromText(readTail(join(relayDir, UPDATE_LOG))) });
+        // 在线更新改写了插件/运行环境文件 → 版本对不上时由 pluginInstalledAfterBoot() 自动识别，
+        // 面板会提示"刷新页面"。这里**不再**写"需要重启 DeepSeek harness"的待重启标记：
+        // 插件走 patch 热加载、bridge 是独立进程，重启 harness 已无必要（用户实测反馈）。
+        // 成功不发事件（update_started 已发过，失败才发 update_failed；白名单里没有 update_done，
+        // 硬发只会被服务端静默丢弃）。
+        if (code !== 0) telemetryRecord(relayDir, "update_failed", { fail_code: telemetryFailCodeFromText(readTail(join(relayDir, UPDATE_LOG))) });
       });
       child.on("error", (e) => {
         appendLogLine(relayDir, UPDATE_LOG, `[update] 子进程启动失败: ${e.message}`);
@@ -2839,7 +2894,12 @@ function registerRoutes(ctx, relayDir) {
       handler: async (_req, res) => {
         const latest = await npmLatestVersion();
         const current = PLUGIN_VERSION;
-        sendJson(res, 200, { ok: true, current, latest, outdated: !!latest && latest !== current });
+        // 正规比较：注册表版本**严格大于**本地版本才算有更新。
+        // 这样 0.6.4 < 0.6.4（正式版发布后预设版会正确提示升级），
+        // 而 0.6.4-beta.10 < 0.6.4 也能正确判断；解析不了时退回朴素不等（保守提示）。
+        const cmp = compareVersions(latest, current);
+        const outdated = cmp === null ? Boolean(latest && latest !== current) : cmp > 0;
+        sendJson(res, 200, { ok: true, current, latest, outdated });
       },
     },
     {
@@ -3325,8 +3385,12 @@ export function apply(ctx, config = {}) {
     ctx.logger?.info?.("dsh-remote-web: 检测到 DeepSeek harness 已重启，撤下「需要重启」提示");
   }
   if (!readRestartState(relayDir).pending && pluginInstalledAfterBoot()) {
-    markRestartPending(relayDir, "first-install", "首次安装需要重启 DeepSeek harness");
-    ctx.logger?.info?.("dsh-remote-web: 插件文件晚于本次进程启动 → 需要重启 DeepSeek harness");
+    // 唯一还需要用户动一下的情形:插件文件晚于本进程启动才落盘(= 运行中被市场安装/在线更新改写),
+    // 此时本进程里没有本插件的路由与面板。**先让用户刷新页面**(客户端半随之更新);
+    // 只有刷新后仍无面板才需要重启(那时多半是 profile patch 行没被 HMR 读到)。
+    // 不再对"首次安装/在线更新完成"提示重启:插件走 patch 热加载、bridge 是独立进程,重启 harness 无必要。
+    markRestartPending(relayDir, "refresh", "插件已更新，刷新页面即可生效");
+    ctx.logger?.info?.("dsh-remote-web: 插件文件晚于本次进程启动 → 提示刷新页面");
   }
   ctx.effect(() => registerRoutes(ctx, relayDir), "dsh-remote-web: /dsh-remote routes");
   // 0.1.2-rc.1+ 浏览器会话代持：换取 Harness 会话 Cookie 供 bridge 上游携带（手机点设备不再 401 白页）

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

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

@@ -1,7 +1,11 @@
-// 【自动化】首次安装/更新后「自动重启 DeepSeek harness」的安全回归（浏览器半，0.6.4）。
+// 【自动化】「自动重启 dsh web」的安全回归（浏览器半，0.6.4）。
 //
-// 目标：用户装完不需要点任何按钮 —— 面板发现「待重启」后自己倒计时重启，重启后自动恢复页面
+// 目标：**确实需要重启时**，用户不必自己点按钮 —— 面板发现待重启后自己倒计时重启，重启后自动恢复页面
 // （复用既有 restartHarness + waitHarnessBack：轮询到 harness 回来即自动刷新）。
+//
+// ⚠️ 0.6.4-beta.9 起：kind="refresh"（插件被运行时改写 → 只需刷新页面）**不再自动重启**，
+// 因为刷新是零风险动作、重启会打断用户正在进行的会话。因此本用例用 kind="update"
+// （非 refresh）来构造"确实需要重启"的场景，以覆盖倒计时链路。
 // 但「自动重启进程」是危险动作，本用例锁死四条安全阀：
 //   ① 只在面板可见时计时（用户没在看就不动）；
 //   ② 15 秒倒计时内可一键取消，取消标记按本次事件（restart.at）持久化，同一事件不再自动重启；
@@ -40,7 +44,9 @@ const LOGGED = { ok: true, config: { phone: "138****0000", hasPhone: true, mode:
 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 } });
+  // kind 用 "update"(非 refresh):只有这一路才走自动重启倒计时;
+  // kind="refresh" 的面板只提示刷新页面(见 harness-restart.test.mjs)。
+  return Object.assign({}, LOGGED, { restart: { pending: !!pending, kind: "update", reason: "需要重启 dsh web 才能载入新插件", at: at || 0 } });
 }
 
 function loadPlugin(opts = {}) {
@@ -238,7 +244,7 @@ function loadPlugin(opts = {}) {
 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, "需要重启 dsh web 才能载入新插件"), "应显示待重启横幅");
   assert.ok(textHas(tree, "秒后自动重启"), "应显示自动重启倒计时文案");
   assert.equal(plugin.counts().restartCalls, 0, "倒计时期间不得提前重启");
 

package/packages/dsh-remote-web/test/harness-restart.test.mjs

@@ -1,9 +1,16 @@
-// 「首次安装需要重启 DeepSeek harness」回归（0.6.2 新增）。
+// 「插件装载 / 刷新 / 重启」回归（0.6.2 新增，0.6.4-beta.9 语义修订）。
 //
 // 产品诉求（用户原话）：
-//   1. 安装完成后桌面端 UI 直接可用，并提示「首次安装需要重启 DeepSeek harness」，旁边给「重启」按钮；
-//   2. 常驻入口最底下要有「重启 DeepSeek harness」按钮；
-//   3. 首次打开（尚未重启）时，该按钮要出现在上方显眼位置。
+//   1. 安装完成后桌面端 UI 直接可用；
+//   2. 常驻入口最底下要有「重启 dsh web」按钮（排查用，始终可达）；
+//   3. 需要用户动一下时，该提示要出现在上方显眼位置。
+//
+// ⚠️ 0.6.4-beta.9 语义修订（用户反馈「能热加载了，这个设置窗口就不需要了」）：
+//   插件已改为 profile patch **热加载**装载（HMR 监听 cordis.patch.yml，存盘约 1 秒生效），
+//   运行环境(bridge)又是独立 launchd 进程 —— 所以「装插件 / 在线更新完成」都**不再需要重启
+//   DeepSeek harness**，那条横幅确实是误导。现在只在一种情形提示用户：
+//   **磁盘上的插件文件比当前进程新**（= 运行中被市场安装/在线更新改写），文案是
+//   「插件已更新，刷新页面即可生效」，并且**不自动重启**（刷新零风险，重启会打断用户会话）。
 //
 // 机制：dsh web 的插件（宿主半 + 浏览器半）都在**进程启动时**装载，市场安装/在线更新只是把文件
 // 写进 profile，当前进程里既没有 /dsh-remote/* 路由也没有面板入口 → 必须重启才生效。
@@ -12,7 +19,7 @@
 import assert from "node:assert/strict";
 import http from "node:http";
 import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -107,7 +114,7 @@ async function serve(routes) {
 
 // ─────────────────────────── 宿主半：状态机 ───────────────────────────
 
-test("首次安装（运行环境在本进程内补齐）→ 自动标记「需要重启」并在 /status 下发", async () => {
+test("首次安装（运行环境在本进程内补齐）→ **不再**提示重启 harness（热加载后已无必要）", async () => {
   const env = await setup();
   try {
     await writeConfig(env.relayDir);
@@ -118,16 +125,52 @@ test("首次安装（运行环境在本进程内补齐）→ 自动标记「需
     const { host, base } = await serve(routes);
     try {
       const before = await (await fetch(`${base}/dsh-remote/status`)).json();
-      assert.equal(before.restart.pending, false, "运行环境补齐前不该提示重启");
+      assert.equal(before.restart.pending, false, "运行环境补齐前不该有提示");
 
       // 模拟后台 npx 安装完成：固化运行时落盘
       await writeFile(path.join(env.relayDir, "dsh-setup.mjs"), "// runtime stub");
-      await waitFor(async () => readFile(env.stateFile, "utf8").then(() => true).catch(() => false));
+      await sleep(400); // 给自愈调度一轮时间(以前这一轮会 markRestartPending)
 
       const after = await (await fetch(`${base}/dsh-remote/status`)).json();
-      assert.equal(after.restart.pending, true, "运行环境刚补齐 → 应提示需要重启 DeepSeek harness");
-      assert.equal(after.restart.kind, "first-install");
-      assert.match(String(after.restart.reason), /首次安装需要重启 DeepSeek harness/);
+      // bridge 是独立 launchd 进程、插件走 patch 热加载 → 补齐运行环境不需要重启 harness。
+      // 旧行为(提示"首次安装需要重启 DeepSeek harness")已被用户实测判定为误导,故断言必须为 false。
+      assert.equal(after.restart.pending, false,
+        "运行环境补齐**不该**再提示重启 harness（热加载 + 独立 bridge 进程）");
+    } finally { host.close(); routes.dispose(); }
+  } finally { await env.restore(); }
+});
+
+test("补装把**同版本**插件重写一遍 → 不得提示（用户实测的误报）", async () => {
+  // 事故复盘:安装器/自愈补装会把 profile 副本整目录重写,即使是**同一个版本**。
+  // 旧实现只看"插件文件 mtime 晚于进程启动"→ 误判成"有新插件要装载"→ 弹出需要重启/刷新的横幅,
+  // 而用户刷新后横幅还在(因为第二次补装又写了一遍)、最后靠重启才消失。
+  // 现在判的是「磁盘版本 != 运行版本」,版本相同就什么都不提示。
+  const src = readFileSync(new URL("../lib/index.js", import.meta.url), "utf8");
+  const fn = src.slice(src.indexOf("function pluginInstalledAfterBoot("), src.indexOf("/** 本进程的启动命令"));
+  assert.match(fn, /diskVersion !== runningVersion/, "必须比较版本,而不是只看时间戳");
+  assert.match(fn, /PLUGIN_VERSION/, "必须用本进程装载的版本号做比较");
+});
+
+test("插件文件晚于本进程启动 → 提示「刷新页面」，且**不**自动重启", async () => {
+  const env = await setup();
+  try {
+    await writeConfig(env.relayDir);
+    await writeFile(path.join(env.relayDir, "dsh-setup.mjs"), "// runtime stub");
+    const routes = boot(env.relayDir);
+    const { host, base } = await serve(routes);
+    try {
+      const cur = await (await fetch(`${base}/dsh-remote/status`)).json();
+      // 用**真实的 bootId** 写回状态:否则 settleRestartState 会判定"这是上个进程写的 = 已重启过"
+      // 而把提示结清(那样就测不到"同进程内保留提示"这条语义了)。
+      await writeFile(env.stateFile, JSON.stringify({
+        pending: true, kind: "refresh", reason: "插件已更新，刷新页面即可生效",
+        at: Date.now() - 3000, bootId: cur.restart.bootId
+      }));
+
+      const st = await (await fetch(`${base}/dsh-remote/status`)).json();
+      assert.equal(st.restart.pending, true, "插件被运行时改写 → 应提示");
+      assert.equal(st.restart.kind, "refresh", "kind 必须是 refresh（刷新语义，不是重启）");
+      assert.match(String(st.restart.reason), /刷新页面/);
     } finally { host.close(); routes.dispose(); }
   } finally { await env.restore(); }
 });
@@ -148,18 +191,31 @@ test("重启已完成（bootId 变化）→ 自动撤下提示；同一进程内
     } finally { host.close(); routes.dispose(); }
   } finally { await a.restore(); }
 
-  // 场景 B：状态由**当前进程**写下（用户还没点重启，只是刷新了页面 / 插件重新装载）→ 必须保留。
-  // 走真实链路：插件自己写 pending（运行环境在本进程内补齐），再在同一进程内重新装载一次。
+  // 场景 B：状态由**当前进程**写下（用户还没处理，只是刷新了页面 / 插件重新装载）→ 必须保留提示。
+  // 注:0.6.4-beta.9 起"运行环境在本进程内补齐"不再写待重启(热加载后无必要),
+  // 所以这里直接按**真实 bootId** 写一份 kind=refresh 状态来构造该场景。
   const b = await setup();
   try {
     await writeConfig(b.relayDir);
+    await writeFile(path.join(b.relayDir, "dsh-setup.mjs"), "// runtime stub");
     process.env.DSH_RELAY_SELFHEAL_MS = "200";
+    // 本进程的 bootId:必须与 lib/index.js 的 BOOT_ID 完全一致,否则 settleRestartState
+    // 会判定"状态来自上一个进程 = 重启已完成"而把提示结清。
+    // 构造方式与 lib 相同;lib 对外不导出它,状态文件只在有 pending 时才写,故这里自行推出。
+    const sameProcessBootId = `${process.pid}-${Math.round(Date.now() - process.uptime() * 1000)}`;
     const routes1 = boot(b.relayDir);
     const { host: host1, base: base1 } = await serve(routes1);
-    await writeFile(path.join(b.relayDir, "dsh-setup.mjs"), "// runtime stub");
-    await waitFor(async () => readFile(b.stateFile, "utf8").then(() => true).catch(() => false));
-    const st1 = await (await fetch(`${base1}/dsh-remote/status`)).json();
-    assert.equal(st1.restart.pending, true, "运行环境补齐后应标记待重启");
+    await writeFile(b.stateFile, JSON.stringify({
+      pending: true, kind: "refresh", reason: "插件已更新，刷新页面即可生效",
+      at: Date.now() - 3000, bootId: sameProcessBootId
+    }));
+    // 把状态文件的 mtime 置为"刚写过":pluginInstalledAfterBoot() 判的是"插件文件晚于本进程启动"。
+    // 不这么做,第二次 apply() 的条件 `!pending && pluginInstalledAfterBoot()` 会为真,
+    // 于是 markRestartPending 又写一次(新 at/bootId),测的就不是"settle 不清"这条语义了。
+    const nowMs = Date.now() / 1000;
+    await utimes(b.stateFile, nowMs, nowMs);
+    const st1b = await (await fetch(`${base1}/dsh-remote/status`)).json();
+    assert.equal(st1b.restart.pending, true, "同进程写下的待处理状态应保留");
     host1.close();
     routes1.dispose();
 
@@ -169,7 +225,7 @@ test("重启已完成（bootId 变化）→ 自动撤下提示；同一进程内
     try {
       const st2 = await (await fetch(`${base2}/dsh-remote/status`)).json();
       assert.equal(st2.restart.pending, true, "同一进程内（还没真重启）不得误撤提示");
-      assert.equal(st2.restart.bootId, st1.restart.bootId, "bootId 应在同一进程内稳定不变");
+      assert.equal(st2.restart.bootId, sameProcessBootId, "bootId 应在同一进程内稳定不变");
     } finally { host2.close(); routes2.dispose(); }
   } finally { await b.restore(); }
 });
@@ -299,15 +355,11 @@ function loadPlugin(statusBody) {
   return { requests, states, render() { hook = 0; return registered.get("dsh-remote")({ close() {} }); } };
 }
 
-const STATUS_FIRST_INSTALL = {
+// 现在唯一会提示用户的状态是 kind=refresh（插件文件被运行时改写 → 刷新页面即可）
+const STATUS_REFRESH = {
   ok: true, config: { phone: "13800000000", deviceId: "dev-x" },
   service: { running: true, runtimeReady: true, launchd: {} },
-  restart: { pending: true, kind: "first-install", reason: "首次安装需要重启 DeepSeek harness" },
-};
-const STATUS_UPDATE = {
-  ok: true, config: { phone: "13800000000", deviceId: "dev-x" },
-  service: { running: true, runtimeReady: true, launchd: {} },
-  restart: { pending: true, kind: "update", reason: "已在线更新，需要重启 DeepSeek harness 生效" },
+  restart: { pending: true, kind: "refresh", reason: "插件已更新，刷新页面即可生效", at: Date.now() },
 };
 const STATUS_IDLE = {
   ok: true, config: { phone: "13800000000", deviceId: "dev-x" },
@@ -315,21 +367,26 @@ const STATUS_IDLE = {
   restart: { pending: false },
 };
 
-test("UI：待重启 → 顶部醒目提示「首次安装需要重启 DeepSeek harness」+ 重启按钮", () => {
+test("UI：插件更新后 → 顶部提示「刷新页面即可生效」+ 刷新按钮（不再喊重启 harness）", () => {
   const plugin = loadPlugin({
     ok: true,
     config: { phone: "13800000000", deviceId: "dev-x" },
     service: { running: true, runtimeReady: true, launchd: {} },
-    restart: { pending: true, kind: "first-install", reason: "首次安装需要重启 DeepSeek harness" },
+    restart: { pending: true, kind: "refresh", reason: "插件已更新，刷新页面即可生效" },
   });
-  plugin.states[0] = STATUS_FIRST_INSTALL; // mock 的 useEffect 不执行 → 直接注入面板状态
+  plugin.states[0] = STATUS_REFRESH; // mock 的 useEffect 不执行 → 直接注入面板状态
   const tree = plugin.render();
-  assert.ok(textHas(tree, "首次安装需要重启 DeepSeek harness"), "顶部应出现首次安装重启提示");
+  assert.ok(textHas(tree, "插件已更新，刷新页面即可生效"), "顶部应出现刷新提示");
+  // 不能再说"需要重启 DeepSeek harness" —— 热加载后那是误导（用户实测反馈）
+  assert.ok(!textHas(tree, "需要重启 DeepSeek harness"), "不应再出现「需要重启 DeepSeek harness」");
   const alert = find(tree, (n) => n.props && n.props.className === "dru-restart-alert");
   assert.ok(alert, "应有醒目提示块（dru-restart-alert）");
-  const btns = findAll(tree, (n) => n.props && String(n.props.className || "").includes("dru-btn") &&
-    (n.children || []).some((c) => typeof c === "string" && c.includes("重启 DeepSeek harness")));
-  assert.ok(btns.length >= 2, "提示块内 + 底部常驻各一个重启按钮，实际 " + btns.length);
+  // 主按钮应是「刷新页面」
+  const refreshBtn = find(tree, (n) => n.props && String(n.props.className || "").includes("dru-btn-primary") &&
+    (n.children || []).some((c) => typeof c === "string" && c.includes("刷新页面")));
+  assert.ok(refreshBtn, "提示块内主按钮应是「刷新页面」");
+  // 重启按钮仍可达（兜底），但不再是主按钮
+  assert.ok(textHas(tree, "重启 dsh web"), "应保留「重启 dsh web」作为兜底入口");
 });
 
 test("UI：常驻入口最底部始终有「重启 DeepSeek harness」按钮；不需要重启时也不消失", () => {
@@ -341,28 +398,29 @@ test("UI：常驻入口最底部始终有「重启 DeepSeek harness」按钮；
   });
   plugin.states[0] = STATUS_IDLE;
   const tree = plugin.render();
-  assert.ok(!textHas(tree, "首次安装需要重启 DeepSeek harness"), "不需要重启时不该出现顶部提示");
+  assert.ok(!textHas(tree, "刷新页面即可生效"), "不需要动作时不该出现顶部提示");
   const foot = find(tree, (n) => n.props && n.props.className === "dru-restart-foot");
   assert.ok(foot, "底部应常驻重启按钮区（dru-restart-foot）");
-  assert.ok(textHas(foot, "重启 DeepSeek harness"), "常驻区应含重启按钮文案");
+  assert.ok(textHas(foot, "重启 dsh web"), "常驻区应含重启按钮文案（排查兜底，始终可达）");
 });
 
-test("UI：点「重启」→ 调用 /dsh-remote/harness/restart", async () => {
+test("UI：点「重启 dsh web」→ 调用 /dsh-remote/harness/restart", async () => {
   const plugin = loadPlugin({
     ok: true,
     config: { phone: "13800000000", deviceId: "dev-x" },
     service: { running: true, runtimeReady: true, launchd: {} },
-    restart: { pending: true, kind: "update", reason: "已在线更新，需要重启 DeepSeek harness 生效" },
+    restart: { pending: true, kind: "refresh", reason: "插件已更新，刷新页面即可生效" },
   });
-  plugin.states[0] = STATUS_UPDATE;
+  plugin.states[0] = STATUS_REFRESH;
   const tree = plugin.render();
-  // 顶部提示块内的那个按钮（常驻脚注里也有一个）
+  // 顶部提示块内的兜底重启按钮（常驻脚注里也有一个）
   const alert = find(tree, (n) => n.props && n.props.className === "dru-restart-alert");
   const btn = find(alert, (n) => n.props && String(n.props.className || "").includes("dru-btn") &&
-    (n.children || []).some((c) => typeof c === "string" && c.includes("重启 DeepSeek harness")));
+    (n.children || []).some((c) => typeof c === "string" && c.includes("重启 dsh web")));
   assert.ok(btn, "顶部提示块内应能定位到重启按钮");
   btn.props.onClick();
   await new Promise((r) => setImmediate(r));
   assert.ok(plugin.requests.some((r) => r.path === "/dsh-remote/harness/restart" && r.method === "POST"),
     "点击后应 POST /dsh-remote/harness/restart，实际 " + JSON.stringify(plugin.requests));
 });
+

package/packages/dsh-remote-web/test/patch-activation.test.mjs

@@ -181,3 +181,30 @@ test("回归护栏：plugin 子命令必须把激活结果 return 给 setup（
   assert.match(src, /pluginResult = await pluginCmd\(\[\]\)/, "setup 应保存 pluginCmd 的返回值");
   assert.match(src, /pluginResult\.hotPatch/, "应据 hotPatch 判断是否走热挂载形态");
 });
+
+test("硬约束：插件已在 bundles 时**绝不**写 patch 行（两个激活点 = duplicate id 崩溃）", () => {
+  // 事故复盘：patch 行与插件自带 bundle patch 同时生效时，dsh web 启动即
+  //   TypeError: duplicate loader entry id: dsh-remote-web
+  //   Error: dsh: plugin tree failed to load: failed to apply loader entry include (cordis:include)
+  // 整个插件树加载失败（实测生产日志）。所以这两条激活路径必须互斥。
+  const profile = makeProfile({ bundles: [...PLUGIN_BUNDLES, "dsh-remote-web"] });
+  const relay = join(profile, "relay");
+  try {
+    const out = installPlugin(profile, relay);
+    assert.match(out, /已由 dsh\.profile\.bundles 声明/, "应识别并保持 bundles 形态");
+    assert.equal((readPatch(profile).match(/- id: dsh-remote-web/g) || []).length, 0,
+      "bundles 已声明时不得再写 patch 行（否则重复 ID）");
+    assert.ok(readBundles(profile).includes("dsh-remote-web"), "bundles 形态应保持");
+  } finally { cleanup(profile); }
+});
+
+test("硬约束：写入 patch 行后 bundles 必须被清空（单一激活点双向收口）", () => {
+  const profile = makeProfile({ bundles: [...PLUGIN_BUNDLES, "dsh-remote-web"] });
+  const relay = join(profile, "relay");
+  try {
+    installPlugin(profile, relay);
+    const patchRows = (readPatch(profile).match(/- id: dsh-remote-web/g) || []).length;
+    const inBundles = readBundles(profile).filter((b) => b === "dsh-remote-web").length;
+    assert.equal(patchRows + inBundles, 1, `激活点必须恰好一个：patch=${patchRows} bundles=${inBundles}`);
+  } finally { cleanup(profile); }
+});

package/packages/dsh-remote-web/test/setup-output.test.mjs

@@ -109,3 +109,28 @@ test("安装输出:服务状态字符串仍是插件面板可解析的稳定契
   assert.ok(/\? `✅ 运行中/.test(src), "running 口径保留(带 pid)");
   assert.ok(/`未运行 \(\$\{st\.detail \|\| st\.status\}\)`/.test(src), "未运行口径保留(带原因)");
 });
+
+test("版本比较：预设版 < 同号正式版；beta.10 < beta.11（更新提示不能误判）", () => {
+  // 事故背景：面板原本用 `latest !== current` 判断"有没有新版本"，于是
+  // ① 0.6.4-beta.11 与 0.6.4-beta.10 无法比大小；② 正式版 0.6.4 发布后，
+  // 装了 0.6.4-beta.11 的人反而被当成"落后"（其实预设版 semver 低于正式版）。
+  const src = readFileSync(join(HERE, "..", "lib", "index.js"), "utf8");
+  const fnSrc = src.slice(src.indexOf("function compareVersions(a, b)"), src.indexOf("/** 以 detached 子进程执行"));
+  const compare = new Function(`${fnSrc}; return compareVersions;`)();
+  // semver §11：预设版低于同号正式版
+  assert.equal(compare("0.6.4-beta.11", "0.6.4"), -1, "预设版应低于同号正式版");
+  assert.equal(compare("0.6.4", "0.6.4-beta.11"), 1, "正式版应高于同号预设版");
+  // 预设版之间按数字标识符比较（不是字符串比较）
+  assert.equal(compare("0.6.4-beta.11", "0.6.4-beta.10"), 1, "beta.11 > beta.10");
+  assert.equal(compare("0.6.4-beta.10", "0.6.4-beta.9"), 1, "beta.10 > beta.9");
+  assert.equal(compare("0.6.4-beta.10", "0.6.4-beta.10"), 0);
+  // 正式版之间
+  assert.equal(compare("0.6.5", "0.6.4"), 1);
+  assert.equal(compare("0.7.0", "0.6.9"), 1);
+  assert.equal(compare("0.6.4", "0.6.4"), 0);
+  // 解析不了 → null（调用方退回保守判断）
+  assert.equal(compare("weird", "0.6.4"), null);
+  // 路由必须用严格大于判断 outdated
+  assert.match(src, /const cmp = compareVersions\(latest, current\)/, "update-check 应用 semver 比较");
+  assert.match(src, /cmp === null \? Boolean\(latest && latest !== current\) : cmp > 0/);
+});