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

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.10",
   "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,303 @@
+// 【自动化】「自动重启 dsh web」的安全回归（浏览器半，0.6.4）。
+//
+// 目标：**确实需要重启时**，用户不必自己点按钮 —— 面板发现待重启后自己倒计时重启，重启后自动恢复页面
+// （复用既有 restartHarness + waitHarnessBack：轮询到 harness 回来即自动刷新）。
+//
+// ⚠️ 0.6.4-beta.9 起：kind="refresh"（插件被运行时改写 → 只需刷新页面）**不再自动重启**，
+// 因为刷新是零风险动作、重启会打断用户正在进行的会话。因此本用例用 kind="update"
+// （非 refresh）来构造"确实需要重启"的场景，以覆盖倒计时链路。
+// 但「自动重启进程」是危险动作，本用例锁死四条安全阀：
+//   ① 只在面板可见时计时（用户没在看就不动）；
+//   ② 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) {
+  // 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 = {}) {
+  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, "需要重启 dsh web 才能载入新插件"), "应显示待重启横幅");
+  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, "自动重启"), "无待重启时不应出现自动重启文案");
+});

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";
@@ -52,8 +59,16 @@ async function setup({ list = "" } = {}) {
   await writeFile(path.join(fakeBin, "npx"), "#!/bin/sh\nexit 0\n"); await chmodSync(path.join(fakeBin, "npx"), 0o755);
 
   const saved = {};
-  for (const k of ["PATH", "DSH_TEST_LAUNCH_LOG", "DSH_TEST_LIST", "DSH_RELAY_SKIP_SERVICE", "DSH_RELAY_SELFHEAL_MS",
+  for (const k of ["HOME", "PATH", "DSH_TEST_LAUNCH_LOG", "DSH_TEST_LIST", "DSH_RELAY_SKIP_SERVICE", "DSH_RELAY_SELFHEAL_MS",
     "DSH_RELAY_RESTART_DRYRUN", "DSH_SETUP_NPX_DIR"]) saved[k] = process.env[k];
+  // HOME 必须一起伪造：本用例会 unset DSH_RELAY_SKIP_SERVICE 去走真实分支，
+  // 而插件的自启动 plist 路径写作 join(homedir(), "Library/LaunchAgents/…")。
+  // 不伪造 HOME 就会把**指向测试临时目录**的 plist 覆盖到开发者真实的
+  // ~/Library/LaunchAgents/com.dshremote.bridge.plist（实测污染，且临时目录随即被删 →
+  // 真实 bridge 自启动彻底失效）。这是测试对开发者机器的破坏，必须隔离。
+  const fakeHome = path.join(root, "home");
+  await mkdir(path.join(fakeHome, "Library", "LaunchAgents"), { recursive: true });
+  process.env.HOME = fakeHome;
   process.env.PATH = `${fakeBin}:${saved.PATH}`;
   process.env.DSH_TEST_LAUNCH_LOG = path.join(root, "launchctl.log");
   process.env.DSH_TEST_LIST = list;
@@ -99,7 +114,7 @@ async function serve(routes) {
 
 // ─────────────────────────── 宿主半：状态机 ───────────────────────────
 
-test("首次安装（运行环境在本进程内补齐）→ 自动标记「需要重启」并在 /status 下发", async () => {
+test("首次安装（运行环境在本进程内补齐）→ **不再**提示重启 harness（热加载后已无必要）", async () => {
   const env = await setup();
   try {
     await writeConfig(env.relayDir);
@@ -110,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(); }
 });
@@ -140,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();
 
@@ -161,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(); }
 });
@@ -291,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" },
@@ -307,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」按钮；不需要重启时也不消失", () => {
@@ -333,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/launchd-domain.test.mjs

@@ -0,0 +1,78 @@
+/**
+ * macOS 自启动（launchd）契约测试（node:test，零框架）。
+ *
+ * 背景：用户（macOS 26.1）反馈自启动服务登记后**从未被派生**（`runs = 0`），
+ * 安装脚本报「自启动服务启动失败：服务未在运行」。根因：
+ *   ① macOS 26 会把 `gui/<uid>` domain 置于 on-demand-only 模式，`RunAtLoad` / `KeepAlive`
+ *      全部失效（只登记不派生）；系统日志：`pending spawn, domain in on-demand-only mode`。
+ *      迁到 `user/<uid>` domain（并带 `LimitLoadToSessionType`）才能恢复派生与崩溃自愈。
+ *   ② 旧实现 `bootstrap` 后**立刻** `print` 一次就判定失败 —— launchd 派生是异步的。
+ *   ③ 从不调用 `launchctl kickstart`，所以被挂起时没有任何东西会把它拉起来。
+ *   ④ plist 的 PATH 缺 `/usr/sbin`、`/sbin`，bridge 日志里刷 `ioreg: command not found`。
+ *
+ * 本机实测（macOS 14.4.1，同机验证）：
+ *   · `bootstrap user/501 <plist 无 LimitLoadToSessionType>` → rc=5 `Input/output error`
+ *   · 带 `[Aqua, Background]` 后：user/501 与 gui/501 都装载成功且 `runs = 1`
+ *   · user/501 下 `kill -9` 后 launchd 自动重建 → `runs = 2`（KeepAlive 真生效）
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const SETUP = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "dsh-setup.mjs");
+const src = readFileSync(SETUP, "utf8");
+
+test("launchd 修复：plist 必须带 LimitLoadToSessionType（user domain 的必要条件）", () => {
+  assert.match(
+    src,
+    /<key>LimitLoadToSessionType<\/key><array><string>Aqua<\/string><string>Background<\/string><\/array>/,
+    "缺该键时 user/<uid> bootstrap 直接 EIO(rc=5);macOS 26 上它也是恢复派生的前提"
+  );
+  // RunAtLoad / KeepAlive 仍需保留：user domain 下它们才真正生效
+  assert.match(src, /<key>RunAtLoad<\/key><true\/>/, "RunAtLoad 不能删（user domain 下靠它开机自启）");
+  assert.match(src, /<key>KeepAlive<\/key><true\/>/, "KeepAlive 不能删（user domain 下靠它崩溃自愈）");
+});
+
+test("launchd 修复：启动走 user → gui 阶梯，且每次都 kickstart", () => {
+  assert.ok(/function startBridgeDarwin/.test(src), "应有专门的 darwin 启动阶梯函数");
+  const fn = src.slice(src.indexOf("function startBridgeDarwin"), src.indexOf("function restartBridgeService"));
+  // 首选 user domain（macOS 26 上唯一支持自启动语义的 domain）
+  assert.ok(/for \(const domain of \[`user\/\$\{uid\}`, `gui\/\$\{uid\}`\]\)/.test(fn), "应为 user → gui 的阶梯顺序");
+  assert.ok(/launchctl kickstart -k/.test(fn), "bootstrap 只是登记,必须 kickstart 才能确保这次起来");
+  // 清掉另一个 domain 的残留，避免两处并存跑出两个 bridge
+  assert.ok(/bootout \$\{d\}\/\$\{BRIDGE_LABEL\}/.test(fn), "切换到某 domain 时应清掉另一 domain 的历史注册");
+  // 终极兜底：launchd 托管不了也要保证「现在能用」
+  assert.ok(/spawnDetachedBridge/.test(fn), "launchd 不可用时应退化为后台进程兜底");
+  assert.ok(/degraded-detached/.test(fn), "兜底状态要与完全失败区分开");
+});
+
+test("launchd 修复：不再只 print 一次就判定失败（异步派生必须轮询）", () => {
+  assert.ok(/function waitLaunchdRunning/.test(src), "应有轮询等待函数");
+  const fn = src.slice(src.indexOf("function launchdState"), src.indexOf("function spawnDetachedBridge"));
+  assert.ok(/for \(let i = 0; i < tries; i \+= 1\)/.test(fn), "应循环轮询而非单次检查");
+  assert.ok(/sleepSync\(gapMs\)/.test(fn), "轮询之间要真正等待");
+  assert.ok(/tries = 20/.test(fn), "总等待时长应足够 launchd 完成异步派生");
+  // 必须能识别「登记了但从未派生」这一 macOS 26 特征，才能给出正确建议而不是干等
+  assert.ok(/pended nondemand spawn/.test(fn) && /on-demand-only/.test(fn), "应识别 on-demand-only 挂起特征");
+});
+
+test("launchd 修复：被挂起后靠 kickstart 起来时，不得报成完全成功", () => {
+  assert.ok(/selfHealing/.test(src), "应回报是否具备崩溃自愈能力");
+  assert.ok(/本机 launchd 处于 on-demand-only/.test(src), "安装输出要如实说明不支持崩溃自愈");
+  const summary = src.slice(src.indexOf("const svcFragile"), src.indexOf("const L = [];"));
+  assert.ok(/svcFragile/.test(summary), "汇总里应区分「可自愈」与「仅拉起一次」");
+});
+
+test("launchd 修复：服务 PATH 必须含 /usr/sbin 与 /sbin（否则 ioreg 找不到）", () => {
+  const m = src.match(/const SERVICE_PATH = "([^"]+)"/);
+  assert.ok(m, "应集中定义 SERVICE_PATH");
+  for (const dir of ["/usr/local/bin", "/opt/homebrew/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]) {
+    assert.ok(m[1].split(":").includes(dir), `PATH 缺少 ${dir}`);
+  }
+  // plist 与 systemd unit 都必须用这个常量，不能各写各的
+  assert.ok(/\$\{SERVICE_PATH\}/.test(src), "plist/systemd 应使用 SERVICE_PATH 常量");
+  assert.ok(!/Environment=PATH=\/usr\/local\/bin:\/usr\/bin:\/bin/.test(src), "systemd unit 不应再写死旧 PATH");
+});