dsh-remote-web 0.6.18 → 0.7.0-beta.2

package/lib/client.js

@@ -2626,6 +2626,11 @@ window.__ModuleLoader__.load({
       // 是否需要重启 DeepSeek harness（首次安装/在线更新后置顶提醒 + 底部常驻按钮）
       var restartInfo = (st && st.restart) || {};
       var restartPending = !!restartInfo.pending;
+      // 宿主形态（node 半下发）：桌面端（Electron）Host 由桌面应用托管，重启这个动作
+      // 在那边**做不到也不该做**（强行退出会弹原生致命错误）。面板据此：
+      //   ① 不自动倒计时重启；② 保留提醒但改文案，引导"退出并重开桌面应用"。
+      // 旧版 host 的响应里没有该字段 → false，行为与改动前完全一致。
+      var desktopHost = !!(st && st.desktopHost);
       // kind === "refresh" = 插件文件在运行中被改写(装完/更新完),只需刷新页面;
       // 其余情况(极为罕见)才提重启 dsh web。
       var isRefreshOnly = restartPending && restartInfo.kind === "refresh";
@@ -3400,8 +3405,16 @@ window.__ModuleLoader__.load({
             waitHarnessBack(0, false);
           })
           .catch(function (e) {
-            setMsg("err", "重启失败: " + e.message + " —— 请手动重启 DeepSeek harness（退出 dsh web 后重新启动）。");
             setBusy("");
+            // 桌面端（Electron 宿主）：Host 由桌面应用托管，重启被**有意拒绝** —— 这不是故障，
+            // 是"这个动作在这里不该做"。用中性提示告知正确做法，不要写成"重启失败"吓用户。
+            var b = e && e.body;
+            if (b && b.status === "desktop-managed") {
+              setSt(b);
+              setMsg("warn", "ℹ️ " + (b.error || "桌面端不能单独重启 Host") );
+              return;
+            }
+            setMsg("err", "重启失败: " + e.message + " —— 请手动重启 DeepSeek harness（退出后重新启动）。");
           });
       };
 
@@ -4737,7 +4750,9 @@ window.__ModuleLoader__.load({
       // ⚠️ isRestartHard(在线更新完成,kind="restart")同理**不**自动重启:这一种现在会在每次
       // 在线更新成功后出现,若照旧 15 秒自动重启,等于"更新完必定打断用户正在做的事"。
       useEffect(function () {
-        if (!restartPending || isRefreshOnly || isRestartHard || busy !== "" || restartCancelled) { setRestartCountdown(null); return undefined; }
+        // ⚠️ desktopHost 时**不自动重启**：桌面端重启 Host 由 Electron 托管，插件无权也不该做
+        // （见 node 半 restartHarness 的说明）。此时只保留文案提醒，动作交给用户「退出并重开应用」。
+        if (!restartPending || isRefreshOnly || isRestartHard || desktopHost || 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);
@@ -4751,7 +4766,7 @@ window.__ModuleLoader__.load({
           restartHarness(); // 已有实现:重启 + 轮询等它回来 + 自动刷新页面
         }, 1000);
         return function () { clearInterval(iv); };
-      }, [restartPending, isRefreshOnly, isRestartHard, restartInfo.at, busy, restartCancelled]);
+      }, [restartPending, isRefreshOnly, isRestartHard, desktopHost, restartInfo.at, busy, restartCancelled]);
 
       // ── 📣 公告（0.6.18）：本组件的 hook 全部追加在**最后一个既有 hook 之后** ──────
       // 🔒 hook 序号铁律（见本组件顶部 2029-2036 的注释）：本组件大量 useState/useCallback/useEffect
@@ -4894,9 +4909,22 @@ window.__ModuleLoader__.load({
           ));
         }
         if (restartPending) {
+          // 桌面端：刷新类照旧（刷新页面即可）；需要重启 Host 的那一类**不给「立即重启」按钮** ——
+          // 桌面端 Host 由 Electron 托管，插件点了也做不到，给个点不动的按钮只会让人以为是 bug。
+          // 改成如实引导：退出并重开 DeepSeek Harness。
+          // ⚠️ 非桌面端必须保持**原有判据 isRestartHard**：改成 isRefreshOnly 会让"历史遗留 kind"
+          // 的文案从"刷新页面即可生效"变成"重启 dsh web 后生效" —— 属于发布版用户可见的文案变更，
+          // 不该混在桌面端适配里顺手做掉。桌面端才走新文案。
+          var restartRowText = desktopHost
+            ? (isRefreshOnly
+              ? "🔄 插件已更新：刷新页面即可生效"
+              : "🔄 插件已更新：退出并重新打开 DeepSeek Harness 后生效")
+            : (isRestartHard
+              ? "🔄 插件已更新：重启 dsh web 后生效"
+              : "🔄 插件已更新：刷新页面即可生效");
           rows.push(h("div", { className: "dru-access-tip-row", key: "restart" },
-            h("span", null, isRestartHard ? "🔄 插件已更新：重启 dsh web 后生效" : "🔄 插件已更新：刷新页面即可生效"),
-            h("button", {
+            h("span", null, restartRowText),
+            (isRefreshOnly || !desktopHost) ? h("button", {
               type: "button",
               className: "dru-linkbtn",
               disabled: busy !== "",
@@ -4904,7 +4932,7 @@ window.__ModuleLoader__.load({
                 if (isRefreshOnly) { try { location.reload(); } catch (e) { /* 忽略 */ } }
                 else restartHarness();
               }
-            }, isRefreshOnly ? "刷新页面" : "立即重启")
+            }, isRefreshOnly ? "刷新页面" : "立即重启") : null
           ));
         }
         rows.push(h("div", { className: "dru-access-tip-row", key: "hint" },
@@ -4945,15 +4973,23 @@ window.__ModuleLoader__.load({
                   h("div", { className: "dru-restart-alert-title" },
                     // 插件已改为 patch 热加载:装插件/在线更新都不再需要重启 harness,
                     // 唯一要用户动一下的情形是"插件文件在运行中被改写"→ 刷新页面即可。
-                    isRestartHard ? "插件已更新，重启 dsh web 后生效"
+                    // 桌面端：需要换 Host 进程的那一类改为引导「退出并重开应用」（插件无权重启 Host）。
+                    isRestartHard
+                      ? (desktopHost ? "插件已更新，退出并重新打开 DeepSeek Harness 后生效"
+                        : "插件已更新，重启 dsh web 后生效")
                       : isRefreshOnly ? "插件已更新，刷新页面即可生效"
-                        : "需要重启 dsh web 才能载入新插件"),
+                        : (desktopHost ? "需要重新打开 DeepSeek Harness 才能载入新插件"
+                          : "需要重启 dsh web 才能载入新插件")),
                   h("div", { className: "dru-restart-alert-sub" },
                     isRestartHard
-                      ? "新版本已经装到这台电脑上，但当前运行的 dsh web 还是旧代码（新的后台路由与面板要等它重新载入）。手机端连接与已登录状态都不受影响；重启期间页面会短暂断开，然后自动恢复。"
+                      ? (desktopHost
+                        ? "新版本已经装到这台电脑上，但当前运行的 DeepSeek Harness 还是旧代码（新的后台路由与面板要等它重新载入）。桌面端的运行环境由应用本身托管，插件不能单独重启它 —— 请退出并重新打开 DeepSeek Harness 应用。手机端连接与已登录状态都不受影响。"
+                        : "新版本已经装到这台电脑上，但当前运行的 dsh web 还是旧代码（新的后台路由与面板要等它重新载入）。手机端连接与已登录状态都不受影响；重启期间页面会短暂断开，然后自动恢复。")
                       : isRefreshOnly
                         ? "刚装好/刚更新的插件已在磁盘上，浏览器里的面板还是旧版本。刷新一下这个页面即可（手机端连接与已登录状态都不受影响）。"
-                        : "当前运行中的 dsh web 里还没有载入这个插件。先刷新页面；如果刷新后仍然看不到面板，再重启一次 dsh web。"),
+                        : (desktopHost
+                          ? "当前运行中的 DeepSeek Harness 里还没有载入这个插件。先刷新页面；如果刷新后仍然看不到面板，请退出并重新打开 DeepSeek Harness 应用。"
+                          : "当前运行中的 dsh web 里还没有载入这个插件。先刷新页面；如果刷新后仍然看不到面板，再重启一次 dsh web。")),
                   // 【自动化】待重启时自动倒计时重启(用户零操作);倒计时期间可一键取消
                   restartCountdown !== null && restartCountdown > 0
                     ? h("div", { className: "dru-restart-auto", role: "status" },
@@ -4974,7 +5010,9 @@ window.__ModuleLoader__.load({
                           onClick: function () { try { location.reload(); } catch (e) { /* 忽略 */ } }
                         }, "刷新页面")
                       : null,
-                    h("button", {
+                    // 桌面端且非"刷新即可"时**不摆重启按钮**：Host 由 Electron 托管，点了必然失败
+                    // （node 半会拒绝并说明原因）。缺省为 null 是 h() 认可的"什么都不渲染"。
+                    (desktopHost && !isRefreshOnly) ? null : h("button", {
                       type: "button",
                       className: "dru-btn " + (isRefreshOnly ? "dru-btn-ghost" : "dru-btn-primary"),
                       disabled: busy !== "",
@@ -5004,14 +5042,20 @@ window.__ModuleLoader__.load({
             : renderHome()
         ),
         // 常驻入口最底部：「重启 DeepSeek harness」按钮始终可达（首次安装/更新/排查都用它）
+        // 桌面端：Host 由 Electron 托管，重启这个动作不存在 → 不摆一个点了必然失败的按钮，
+        // 改为如实说明「退出并重开桌面应用」。后台服务与手机端连接在两种形态下都不受影响。
         h("div", { className: "dru-restart-foot" },
-          h("div", { className: "dru-hint" }, "重启 dsh web：仅在「刷新页面后仍看不到面板」时才需要。日常安装/更新插件已自动热加载，装完刷新页面即可；重启只影响 dsh web 本身，不影响后台服务与手机端连接。"),
-          h("button", {
-            type: "button",
-            className: "dru-btn " + (restartPending ? "dru-btn-primary" : "dru-btn-ghost"),
-            disabled: busy !== "",
-            onClick: function () { restartHarness(); }
-          }, busy === "restart" ? "重启中…" : "🔄 重启 dsh web")
+          h("div", { className: "dru-hint" }, desktopHost
+            ? "重启 DeepSeek Harness：桌面端由应用本身托管运行环境，请直接退出并重新打开应用（无需其他操作）。日常安装/更新插件已自动热加载，装完刷新页面即可；重启不影响后台服务与手机端连接。"
+            : "重启 dsh web：仅在「刷新页面后仍看不到面板」时才需要。日常安装/更新插件已自动热加载，装完刷新页面即可；重启只影响 dsh web 本身，不影响后台服务与手机端连接。"),
+          desktopHost
+            ? null
+            : h("button", {
+              type: "button",
+              className: "dru-btn " + (restartPending ? "dru-btn-primary" : "dru-btn-ghost"),
+              disabled: busy !== "",
+              onClick: function () { restartHarness(); }
+            }, busy === "restart" ? "重启中…" : "🔄 重启 dsh web")
         ),
         renderCommunityModal(),
         // 📣 公告详情弹窗（与交流群弹窗同一层：都挂在面板根上，点遮罩即收起）

package/lib/index.js

@@ -327,20 +327,113 @@ function resolveExecutable(p) {
 }
 
 /** 优先 node@20（node-datachannel 兼容性），回退当前 node。 */
-function preferredNode() {
+/**
+ * 宿主是否跑在 **Electron 的 Node 模式**下（DeepSeek Harness 桌面端的 Host 就是）。
+ *
+ * 桌面端 `process.execPath` 是 **Electron 应用二进制**，不是 node：
+ * 直接 `spawn(process.execPath, [script])` 得到的不是「跑脚本的 node」，
+ * 而是**再启动一个 Electron 应用实例**（还会撞桌面端的单实例锁）。
+ * 必须补 `ELECTRON_RUN_AS_NODE=1`（官方桌面端自己也正是这么做的：
+ * 其内置 CLI 就是 `ELECTRON_RUN_AS_NODE=1 exec <Electron> --expose-internals <cli.js>`）。
+ */
+const IS_ELECTRON_HOST = Boolean(process.versions && process.versions.electron);
+
+/**
+ * 本插件派生的**辅助脚本**（watcher 拉起、在线更新、doctor、运行环境清理、重启助手）
+ * 一律用**当前进程自己的可执行文件**跑 —— 保持既有行为不变（宿主是哪个 node 就用哪个，
+ * 不引入"另找一个 node 可能版本不同"的风险）。
+ * 但桌面端宿主是 Electron：必须补 `ELECTRON_RUN_AS_NODE=1`，否则不是"跑脚本"而是**又开一个桌面端应用**。
+ * 非 Electron 宿主下为空对象，行为与改动前完全一致。
+ */
+const SELF_NODE_ENV = IS_ELECTRON_HOST ? { ELECTRON_RUN_AS_NODE: "1" } : {};
+
+/**
+ * 解析**自启动服务**里应当登记的解释器。
+ *
+ * 这里与 `SELF_NODE_ENV` 是两件事，不能混：服务由系统在**本应用退出之后**拉起，
+ * 所以它登记的解释器必须活过桌面端的退出、甚至更新（.app 路径会变、可能被换掉）。
+ * 因此**真实 node 优先**；只有找不到真实 node 时才回落宿主自身，
+ * 此时若宿主是 Electron，服务定义里也必须带 `ELECTRON_RUN_AS_NODE=1`。
+ *
+ * @returns {{bin:string, electron:boolean}} bin 是可执行文件绝对路径；electron=true 表示
+ *          该文件是 Electron 二进制，服务定义必须补 `ELECTRON_RUN_AS_NODE=1`。
+ */
+/**
+ * DeepSeek Harness **桌面端自带 Node** 的稳定落点候选。
+ *
+ * 为什么需要：桌面端主打的正是**机器上没有系统 node** 的用户；而自启动服务要活过
+ * 桌面端的退出、甚至升级/重装（`.app` 路径会变、可能被换掉）。桌面端把自带运行时装在
+ * **用户目录** `~/.dsh/dsh-runtimes/…`，它不随应用包更新而移动 —— 所以只要它存在，
+ * 就该优先于任何指向 `.app` 内部的路径。
+ *
+ * 目录布局随桌面端版本演进（可能多套一层 runtime/node），故按多个候选探测；
+ * `resolveExecutable()` 会过滤掉不存在的路径，多列无害。
+ * @returns {string[]} 候选可执行文件绝对路径（可能都不存在）。
+ */
+function desktopRuntimeNodeCandidates() {
+  const exe = isWindows() ? "node.exe" : "node";
+  const out = [];
+  // ① 稳定落点：装在**用户目录**，桌面端升级/重装都不动它。
+  //    ⚠️ 真实布局是 `dependencies/node/bin/<exe>`（2026-10-07 拆官方 0.2.0-rc.2 DMG 实测：
+  //    `…/Resources/runtime/primary-runtime/dependencies/node/bin/node` → Node v24.21.0）。
+  //    其余几个是兼容不同版本的兜底；resolveExecutable() 会过滤掉不存在的路径，多列无害。
+  const roots = [
+    process.env.DSH_DESKTOP_RUNTIME_DIR || "",
+    join(homedir(), ".dsh", "dsh-runtimes", "dsh-primary-runtime"),
+    join(homedir(), ".dsh", "dsh-runtimes", "primary-runtime"),
+  ].filter(Boolean);
+  for (const root of roots) {
+    out.push(
+      join(root, "dependencies", "node", "bin", exe),
+      join(root, "bin", exe),
+      join(root, "node", "bin", exe),
+      join(root, "runtime", "bin", exe),
+    );
+  }
+  // ② 应用自己把自带 node 的路径交给子进程（其 `runtime/bin/node` shim 就是靠这个变量）——
+  //    平台无关，且是"应用自己说的"，比我们猜路径可靠。
+  if (process.env.DSH_DESKTOP_NODE_EXECUTABLE) out.push(process.env.DSH_DESKTOP_NODE_EXECUTABLE);
+  // ③ 最后才是指向应用包内部的绝对路径：它是**真实存在的 node**，但会随桌面端更新换路径，
+  //    所以排在稳定落点之后（自启动服务登记它属于"聊胜于无"，好过登记 Electron 本体）。
+  if (isWindows()) {
+    const local = process.env.LOCALAPPDATA || "";
+    if (local) out.push(join(local, "Programs", "DeepSeek Harness", "resources", "runtime", "primary-runtime", "dependencies", "node", exe));
+  } else {
+    out.push(
+      "/Applications/DeepSeek Harness.app/Contents/Resources/runtime/primary-runtime/dependencies/node/bin/node",
+      "/Applications/DSH Desktop.app/Contents/Resources/runtime/primary-runtime/dependencies/node/bin/node",
+    );
+  }
+  return out;
+}
+
+function resolveServiceInterpreter() {
   const candidates = [
     "/opt/homebrew/opt/node@20/bin/node",
     "/usr/local/opt/node@20/bin/node",
+    ...desktopRuntimeNodeCandidates(),
     process.env.DSH_SETUP_NODE20 || "",
   ].filter(Boolean);
   for (const p of candidates) {
     const real = resolveExecutable(p);
-    if (real) return real;
+    if (real) return { bin: real, electron: false };
   }
-  return resolveExecutable(process.execPath) || process.execPath;
+  return { bin: resolveExecutable(process.execPath) || process.execPath, electron: IS_ELECTRON_HOST };
 }
 
-const NODE_BIN = preferredNode();
+const SERVICE_INTERPRETER = resolveServiceInterpreter();
+const NODE_BIN = SERVICE_INTERPRETER.bin;
+/**
+ * 服务定义里（plist 的 EnvironmentVariables / systemd 的 Environment=）必须注入的变量。
+ * 形如 `{ELECTRON_RUN_AS_NODE:"1"}` 或 `{}`。
+ */
+const SERVICE_NODE_ENV = SERVICE_INTERPRETER.electron ? { ELECTRON_RUN_AS_NODE: "1" } : {};
+/** plist `EnvironmentVariables` 里要追加的解释器变量（真实 node 时为空串 → 模板不变）。 */
+const SERVICE_NODE_ENV_PLIST = Object.entries(SERVICE_NODE_ENV)
+  .map(([k, v]) => `<key>${k}</key><string>${v}</string>`).join("");
+/** systemd unit 里要追加的 `Environment=` 行（真实 node 时为空串 → 模板不变）。 */
+const SERVICE_NODE_ENV_UNIT = Object.entries(SERVICE_NODE_ENV)
+  .map(([k, v]) => `Environment=${k}=${v}\n`).join("");
 
 /**
  * 解析 npx 的调用方式。DeepSeek App 拉起 dsh web 时 PATH 只有 /usr/bin:/bin:/usr/sbin:/sbin
@@ -397,6 +490,10 @@ function npxInvocation() {
 
 /** 子进程环境：把 node 目录补进 PATH（npx 及其 shebang 需要），可附加额外变量。 */
 function spawnEnv(extra) {
+  // ⚠️ 这里刻意用 **process.execPath**，不是 NODE_BIN：PATH 首位的用途是让 npx 的
+  // `#!/usr/bin/env node` 解析到**正在跑本插件的那个 node**（与 npxInvocation 同口径）。
+  // NODE_BIN 回答的是另一个问题——"自启动服务里该登记哪个解释器"（真实 node 优先）。
+  // 两者语义不同，混用会悄悄改掉 web 版上 npx 用哪个 node。
   const nodeDir = dirname(process.execPath);
   const base = process.env.PATH || "";
   // PATH 分隔符必须按平台取（Windows 是 ";"，POSIX 是 ":"）：写死 ":" 会把整条 PATH
@@ -406,7 +503,10 @@ function spawnEnv(extra) {
   // 而 bridge 要用 ioreg 之类系统命令（缺了它 → 机器指纹静默退化，见 SERVICE_PATH 注释）。
   const posixDirs = isWindows() ? [] : ["/usr/local/bin", "/opt/homebrew/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
   const PATH = [nodeDir, base, ...posixDirs].filter(Boolean).join(delimiter);
-  return { ...process.env, PATH, ...(extra || {}) };
+  // ⚠️ SELF_NODE_ENV 展开在 extra **之前**（= 保持既有展开顺序，extra 依旧最后说了算）。
+  // 它只含 ELECTRON_RUN_AS_NODE 一个键，而没有任何调用方会去设置这个键，故不存在被误覆盖的场景。
+  // ⚠️ 也不要无条件设置（真实 node 下设了会污染子进程环境、并让 node 版本探测类工具困惑）。
+  return { ...process.env, ...SELF_NODE_ENV, PATH, ...(extra || {}) };
 }
 
 /**
@@ -640,6 +740,34 @@ function applySaaSMode(cfg) {
  * 老版本(无该鉴权)下 connection 服务没有 authenticatedUrl → 静默跳过,行为不变。
  */
 const HARNESS_COOKIE_FILE = ".harness-cookie.json";
+/**
+ * Cookie 按 **authority 分文件**(0.7.0-beta.2 起,2026-10-09 事故根治)。
+ *
+ * 【事故】`~/.dsh-remote/` 只有一份 `.harness-cookie.json`,而 Web 端(3080)与桌面端(每次启动
+ *   随机端口)是**两个宿主进程**,各自的插件都往里写"自己 authority 的 Cookie" → 互相覆盖。
+ *   桥撞 401 后重读磁盘,拿到的是另一个宿主刚写的 Cookie → 重试 → 还是 401 → 再读 → 又被
+ *   覆盖回去……**乒乓,永不自愈**,手机端持续白页(现象与"自愈坏了"一模一样,极易误判)。
+ * 【根治】每个宿主只写自己 authority 的文件:`.harness-cookie.<authority>.json`
+ *   (`:` → `_`,如 `.harness-cookie.127.0.0.1_19387.json`),互不覆盖。旧版共享文件继续**写**
+ *   一份镜像(旧桥还能用),但新桥只认当前上游 authority 的那一份,foreign 一律跳过。
+ *   命名规则与桥半 `clients/dsh-remote/dsh-bridge.mjs` 同名,漂移由
+ *   `clients/dsh-remote/test/harness-cookie-authority.test.mjs` 的跨文件不变量锁住。
+ */
+function authoritySlug(authority) {
+  return String(authority).replace(/[^A-Za-z0-9._-]/g, "_");
+}
+/** 本宿主专属 Cookie 文件名(与桥半同规则)。 */
+function harnessCookieFileFor(authority) {
+  return `${HARNESS_COOKIE_FILE.slice(0, -".json".length)}.${authoritySlug(authority)}.json`;
+}
+/** 本宿主专属「作废」标记名(与桥半同规则)。 */
+function harnessCookieRevokedFileFor(authority) {
+  return `${HARNESS_COOKIE_REVOKED_FILE}.${authoritySlug(authority)}`;
+}
+/** 由本进程 webServer 端口推出 authority(与 bridge 的 Host 口径一致)。 */
+function harnessAuthorityOfPort(port) {
+  return port ? `127.0.0.1:${port}` : "";
+}
 /**
  * 手机端 401「dsh web authentication required; reopen the URL printed by dsh web」的根因就在这里：
  * 该 Cookie 由本插件在进程内经 ?token= 换取后交给 bridge 代持，**dsh web 每次重启都会换签名密钥**，
@@ -686,22 +814,47 @@ async function mintHarnessCookie(ctx, relayDir) {
     if (UNINSTALLED_DIRS.has(relayDir)) return false;
     const out = { authority: `127.0.0.1:${port}`, cookie, mintedAt: Date.now() };
     mkdirSync(dirname(configPathOf(relayDir)), { recursive: true });
-    writeFileSync(join(relayDir, HARNESS_COOKIE_FILE), JSON.stringify(out, null, 2), { mode: 0o600 });
-    hardenFile(join(relayDir, HARNESS_COOKIE_FILE)); // 会话 Cookie ≈ dsh web 的完整访问权，同样要收紧
+    // ① 本宿主专属文件(权威,两个宿主互不覆盖 —— 事故根治点)
+    const ownPath = join(relayDir, harnessCookieFileFor(out.authority));
+    writeFileSync(ownPath, JSON.stringify(out, null, 2), { mode: 0o600 });
+    hardenFile(ownPath); // 会话 Cookie ≈ dsh web 的完整访问权，同样要收紧
+    // ② 旧版共享文件镜像:只为还跑着旧桥(<0.7.0-beta.2)的机器保留 —— 新桥优先读 ①,
+    //    且对 authority 不符的镜像**直接跳过**,所以这里写镜像不会再引发乒乓。
+    const legacyPath = join(relayDir, HARNESS_COOKIE_FILE);
+    writeFileSync(legacyPath, JSON.stringify(out, null, 2), { mode: 0o600 });
+    hardenFile(legacyPath);
     return true;
   } catch {
     return false;
   }
 }
 
-/** 读取当前 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;
+/**
+ * 读取当前 authority 可用的 Cookie 文件状态:{cookie, authority, mintedAt} 或 null。
+ *   ① 本宿主专属文件优先;
+ *   ② 旧版共享文件仅在 authority 对得上、或旧插件没写 authority 字段(兼容)时采用;
+ *   ③ 声明了别的 authority → 明确不用(那属于另一个宿主,用了必然 401)。
+ * @param {string} relayDir 配置目录
+ * @param {string} [authority] 本进程 authority(`127.0.0.1:<port>`);缺省只做兼容读取
+ */
+function readHarnessCookie(relayDir, authority) {
+  const read = (file) => {
+    try {
+      const j = JSON.parse(readFileSync(join(relayDir, file), "utf8"));
+      return j && typeof j.cookie === "string" && j.cookie ? j : null;
+    } catch {
+      return null;
+    }
+  };
+  if (authority) {
+    const own = read(harnessCookieFileFor(authority));
+    if (own) return own;
   }
+  const legacy = read(HARNESS_COOKIE_FILE);
+  if (!legacy) return null;
+  const claimed = typeof legacy.authority === "string" ? legacy.authority : "";
+  if (claimed === "" || !authority || claimed === authority) return legacy;
+  return null; // foreign authority:另一个宿主的 Cookie,本宿主用不了
 }
 
 let harnessMintInflight = false;
@@ -719,9 +872,22 @@ let harnessMintLastAt = 0;
  */
 async function ensureHarnessCookie(ctx, relayDir, opts) {
   const force = !!(opts && opts.force);
-  const revoked = existsSync(join(relayDir, HARNESS_COOKIE_REVOKED_FILE));
+  const authority = harnessAuthorityOfPort(ctx.webServer?.port);
+  const ownRevokedPath = authority ? join(relayDir, harnessCookieRevokedFileFor(authority)) : "";
+  const legacyRevokedPath = join(relayDir, HARNESS_COOKIE_REVOKED_FILE);
+  const cur = readHarnessCookie(relayDir, authority);
+  // 作废标记两个来源:
+  //   ① 本宿主专属标记(新桥 0.7.0-beta.2+ 写)—— 精确,不会被人家的 401 催着重换;
+  //   ② 旧版共享标记(旧桥写)—— 仅当它**晚于**我们手上这份 Cookie 时才认:说明是它被拒了。
+  //      否则(比如另一个宿主刚被拒、标记比我们的 Cookie 还旧)不理会,避免两个宿主互相催。
+  let revoked = ownRevokedPath !== "" && existsSync(ownRevokedPath);
+  if (!revoked && existsSync(legacyRevokedPath)) {
+    try {
+      const revokedAt = Number(readFileSync(legacyRevokedPath, "utf8").trim()) || 0;
+      revoked = !cur || revokedAt > Number(cur.mintedAt || 0);
+    } catch { /* 标记读不到就当没有 */ }
+  }
   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;              // 去重:同一时刻只换一次
@@ -731,7 +897,11 @@ async function ensureHarnessCookie(ctx, relayDir, opts) {
   try {
     const ok = await mintHarnessCookie(ctx, relayDir);
     if (ok || revoked) {
-      try { rmSync(join(relayDir, HARNESS_COOKIE_REVOKED_FILE), { force: true }); } catch { /* ignore */ }
+      // 清标记:① 本宿主专属标记(精确);② 旧版共享标记(旧桥写的,清了不影响新桥)。
+      // 代价:多宿主机器上可能清掉"另一个宿主"的旧标记 —— 那只让对方的**快速**自愈退化成
+      // 30 分钟周期刷新,不会造成错误状态,故不做更细的归属判定(复杂度不值)。
+      if (ownRevokedPath) { try { rmSync(ownRevokedPath, { force: true }); } catch { /* ignore */ } }
+      try { rmSync(legacyRevokedPath, { force: true }); } catch { /* ignore */ }
     }
     if (!ok && revoked) console.warn("[dsh-remote-web] 浏览器会话 Cookie 已被 dsh web 作废,重取失败,下次查状态再试");
     return ok;
@@ -902,7 +1072,7 @@ ExecStart=${NODE_BIN} ${setup} run
 Restart=on-failure
 RestartSec=5
 Environment=PATH=${SERVICE_PATH}
-Environment=DSH_BRIDGE_UPSTREAM=${upstreamUrl()}
+${SERVICE_NODE_ENV_UNIT}Environment=DSH_BRIDGE_UPSTREAM=${upstreamUrl()}
 Environment=DSH_BRIDGE_INSTALL_SOURCE=${installSourceOf(relayDir)}
 Environment=DSH_BRIDGE_INSTALL_VERSION=${PLUGIN_VERSION}
 
@@ -1483,7 +1653,7 @@ function writeAutostartFile(relayDir) {
   <key>LimitLoadToSessionType</key><array><string>Aqua</string><string>Background</string></array>
   <key>StandardOutPath</key><string>${join(relayDir, ".dsh-bridge.log")}</string>
   <key>StandardErrorPath</key><string>${join(relayDir, ".dsh-bridge.log")}</string>
-  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${SERVICE_PATH}</string><key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${installSourceOf(relayDir)}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${PLUGIN_VERSION}</string></dict>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${SERVICE_PATH}</string>${SERVICE_NODE_ENV_PLIST}<key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${installSourceOf(relayDir)}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${PLUGIN_VERSION}</string></dict>
 </dict></plist>`;
   mkdirSync(dirname(plistPath), { recursive: true });
   writeFileSync(plistPath, plist, { mode: 0o644 });
@@ -2127,6 +2297,22 @@ logLine("已重新拉起 dsh web：pid=" + String(child.pid));
  */
 async function restartHarness(relayDir, opts = {}) {
   if (skipsSystemOps()) return { ok: false, status: "skipped", detail: "测试隔离（DSH_RELAY_SKIP_SERVICE=1）：跳过真实重启" };
+  // 桌面端（Electron 宿主）：**绝不重启 Host**。
+  //   · Host 是桌面应用（Electron）的子进程，把它杀掉会触发桌面端的**原生致命恢复弹窗**，
+  //     用户的观感是"应用崩了"，远差于"没重启"；
+  //   · 而且桌面端重启用处很小：插件由共享插件管理器安装、激活走 profile 的 patch HMR
+  //     （存盘后约 1 秒重新 compose），日常更新刷新页面即可生效；
+  //   · 真要重启，正确动作是**退出并重开桌面应用**，那由用户/操作系统负责，不该由插件代劳。
+  // 因此这里如实返回"做不到 + 该怎么做"，而不是假装成功或把宿主打死。
+  if (IS_ELECTRON_HOST) {
+    return {
+      ok: false,
+      status: "desktop-managed",
+      mode: "desktop",
+      detail: "当前运行在 DeepSeek Harness 桌面端：Host 由桌面应用托管，插件不能单独重启它（强行退出会让应用弹致命错误）。"
+        + "插件更新一般刷新页面即可生效；确实需要重启时，请退出并重新打开 DeepSeek Harness —— 后台服务与手机端连接不受影响。",
+    };
+  }
   const cmd = selfCommand();
   let mode = "relaunch";
   let target = "";
@@ -3777,6 +3963,9 @@ function spawnRuntimeCleanupDetached(relayDir, protectedPath) {
     writeFileSync(helperPath, buildRuntimeCleanupHelper(relayDir, protectedPath));
     const { child, error } = safeSpawn(process.execPath, [helperPath], {
       detached: true, cwd: homedir(), stdio: "ignore", windowsHide: true,
+      // ⚠️ 必须带 spawnEnv：桌面端宿主下 process.execPath 是 Electron 二进制，
+      // 不补 ELECTRON_RUN_AS_NODE=1 的话这里不是"跑清理脚本"，而是**又开一个桌面端应用**。
+      env: spawnEnv({}),
       onError: (e) => console.warn(`[dsh-remote-web] 运行时清理子进程启动失败: ${e.message}`),
     });
     if (error || !child) {
@@ -4340,6 +4529,11 @@ async function composeConnect(relayDir, opts = {}) {
     watcherRestarts: wedge.restarts,
     upstreamUrl: upstreamUrl(),
     upstreamSource: upstreamSourceLabel(),
+    // 宿主形态：桌面端（Electron）与 Web 版（node）在若干动作上语义不同 ——
+    // 最典型的是「重启 DeepSeek harness」在桌面端做不到也不该做（Host 由 Electron 托管，
+    // 强行退出会弹原生致命错误）。面板据此改文案/去掉无意义的按钮，而不是等用户点了才失败。
+    desktopHost: IS_ELECTRON_HOST,
+    restartSupported: !IS_ELECTRON_HOST,
     upstreamReachable: upstream ? upstream.ok : null,
     upstreamError: upstream && !upstream.ok ? upstream.error : "",
     rateLimitedUntil,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.6.18",
+  "version": "0.7.0-beta.2",
   "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",
@@ -42,6 +42,9 @@
   "homepage": "https://github.com/mrRisega/dsh-remote/tree/main/packages/dsh-remote-web#readme",
   "license": "PolyForm-Noncommercial-1.0.0",
   "engines": {
-    "dsh": ">=0.1.0-rc.6 <0.2.0-0"
+    "dsh": ">=0.1.0-rc.6 <0.3.0-0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh": ">=0.1.0-rc.6 <0.3.0-0"
   }
 }

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

@@ -320,21 +320,100 @@ const HARNESS_COOKIE_FILE = ".harness-cookie.json";
 const HARNESS_UNAUTHORIZED_TEXT = "dsh web authentication required";
 /** 撞到 401 时写的「作废」标记:插件在面板轮询时看到它就会立刻重换 Cookie(见 node 半 ensureHarnessCookie)。 */
 const HARNESS_COOKIE_REVOKED_FILE = ".harness-cookie-revoked";
-function markHarnessCookieRevoked() {
+
+/**
+ * Cookie 按 **authority 分文件**(0.7.0-beta.2 起,2026-10-09 事故根治)。
+ *
+ * 【事故】`~/.dsh-remote/` 只有一份 `.harness-cookie.json`,而 Web 端(3080)与桌面端(每次启动
+ *   随机端口)是**两个宿主、两个进程**,各自的插件都会往里写"自己 authority 的 Cookie" →
+ *   互相覆盖。桥撞 401 后重读磁盘,拿到的是**另一个宿主刚写的** Cookie(与失败的不是同一个)
+ *   → 重试 → 还是 401 → 再读 → 又被覆盖回去……**乒乓,永不自愈**。手机端持续白页。
+ * 【根治】每个宿主只写自己 authority 的文件:`.harness-cookie.<authority>.json`
+ *   (`:` 换成 `_`,如 `.harness-cookie.127.0.0.1_19387.json`),互不覆盖;桥只认
+ *   **当前上游 authority** 的那一份。旧版共享文件继续兼容读取,但**foreign authority 一律不用**
+ *   —— 那正是乒乓的来源。命名规则与插件半 `packages/dsh-remote-web/lib/index.js` 同名,
+ *   漂移由 `test/harness-cookie-authority.test.mjs` 的跨文件不变量锁住。
+ */
+function authoritySlug(authority) {
+  return String(authority).replace(/[^A-Za-z0-9._-]/g, "_");
+}
+/** 本宿主专属 Cookie 文件名(与插件半同规则)。 */
+function harnessCookieFileFor(authority) {
+  return `${HARNESS_COOKIE_FILE.slice(0, -".json".length)}.${authoritySlug(authority)}.json`;
+}
+/** 本宿主专属「作废」标记名(与插件半同规则)。 */
+function harnessCookieRevokedFileFor(authority) {
+  return `${HARNESS_COOKIE_REVOKED_FILE}.${authoritySlug(authority)}`;
+}
+/** 当前上游的 authority(`127.0.0.1:<port>`);取不到返回空串。 */
+function upstreamAuthorityOf(upstream) {
   try {
-    const p = path.join(path.dirname(CONFIG_PATH), HARNESS_COOKIE_REVOKED_FILE);
-    fs.writeFileSync(p, String(Date.now()), { mode: 0o600 });
-  } catch { /* 忽略:标记只为加速自愈 */ }
+    return new URL(String(upstream || UPSTREAM)).host || "";
+  } catch {
+    return "";
+  }
+}
+/** 已就"哪个 foreign authority 在抢"告警过的集合(每对只吵一次,不刷屏)。 */
+const foreignCookieWarned = new Set();
+function warnForeignCookieOnce(claimed, authority) {
+  const key = `${claimed}->${authority}`;
+  if (foreignCookieWarned.has(key)) return;
+  foreignCookieWarned.add(key);
+  console.warn(
+    `[bridge] 检测到另一宿主的会话 Cookie(${claimed}),而当前上游是 ${authority} —— ` +
+    `一台机器只能服务一个宿主,已跳过该 Cookie(不再乒乓重试)。` +
+    `若手机端仍 401,请确认 .dsh-upstream 指向正在运行的那个宿主,并让该宿主的插件重发 Cookie。`
+  );
+}
+function readCookieDoc(dir, file) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(dir, file), "utf8"));
+    return j && typeof j.cookie === "string" && j.cookie ? j : null;
+  } catch {
+    return null;
+  }
 }
+/**
+ * 当前上游该用的浏览器会话 Cookie(空串 = 没有可用的)。
+ *
+ * 取值顺序(2026-10-09 起):
+ *   ① 本宿主专属文件 `.harness-cookie.<authority>.json` —— 新插件写的,权威;
+ *   ② 旧版共享 `.harness-cookie.json` —— 仅当它声明的 `authority` 与当前上游一致,
+ *      或旧插件根本没写 authority 字段(向后兼容)时才用;
+ *   ③ 声明了**别的** authority → 明确不用,并告警一次(这就是乒乓的源头)。
+ */
 function harnessCookieOf() {
+  const dir = path.dirname(CONFIG_PATH);
+  const authority = upstreamAuthorityOf();
+  if (authority) {
+    const own = readCookieDoc(dir, harnessCookieFileFor(authority));
+    if (own) return own.cookie;
+  }
+  const legacy = readCookieDoc(dir, HARNESS_COOKIE_FILE);
+  if (!legacy) return "";
+  const claimed = typeof legacy.authority === "string" ? legacy.authority : "";
+  if (claimed === "" || authority === "" || claimed === authority) return legacy.cookie;
+  warnForeignCookieOnce(claimed, authority);
+  return "";
+}
+/** 本宿主 Cookie 是否处于「已作废、等插件重换」状态(诊断用,不参与取值)。 */
+function harnessCookieRevokedFor(authority) {
   try {
-    const p = path.join(path.dirname(CONFIG_PATH), HARNESS_COOKIE_FILE);
-    const j = JSON.parse(fs.readFileSync(p, "utf8"));
-    return j && typeof j.cookie === "string" && j.cookie ? j.cookie : "";
+    return fs.existsSync(path.join(path.dirname(CONFIG_PATH), harnessCookieRevokedFileFor(authority)));
   } catch {
-    return "";
+    return false;
   }
 }
+function markHarnessCookieRevoked() {
+  const dir = path.dirname(CONFIG_PATH);
+  const authority = upstreamAuthorityOf();
+  // 只写**本宿主**的标记:两个宿主各写各的,插件侧才不会被人家的 401 反复催着重换。
+  // (旧版共享标记 `.harness-cookie-revoked` 不再写:它是"两个写者抢一份文件"的同款隐患。)
+  if (!authority) return;
+  try {
+    fs.writeFileSync(path.join(dir, harnessCookieRevokedFileFor(authority)), String(Date.now()), { mode: 0o600 });
+  } catch { /* 忽略:标记只为加速自愈 */ }
+}
 
 /**
  * 解析稳定 deviceId:优先级 env DSH_BRIDGE_DEVICE_ID > argv[2] > 配置 device_id > 生成。
@@ -1568,6 +1647,18 @@ function wechatAppUrl() {
 }
 
 let wechatRuntime = null;
+
+/**
+ * 微信事件通道要连的上游（**每次重连都会调一次**）。
+ *
+ * 行为：先顺手触发一次上游重发现（内部有 15s 冷却 + 单飞，反复调用不会打爆 lsof/探测），
+ * 再返回**当下**的 UPSTREAM。这样宿主换端口时通道能自己跟上，而不必重启 bridge。
+ */
+function currentUpstreamForChannel() {
+  void refreshUpstream("微信事件通道重连");
+  return UPSTREAM;
+}
+
 function startWeChat() {
   if (WECHAT_DISABLED) {
     console.log("[bridge] 微信通道已禁用(DSH_WECHAT=0)");
@@ -1578,10 +1669,15 @@ function startWeChat() {
     const cfg = loadLocalConfig();
     wechatRuntime = createWeChatRuntime({
       relayDir,
-      // 上游地址在 runTunnel() 开头已完成动态发现（见 refreshUpstream），所以这里拿到的是真实端口。
-      // ⚠️ 这是**取值**而非引用：运行中若上游端口又变了（自愈重发现），微信通道要等 bridge 重启才跟上；
-      //    隧道转发那一侧不受影响（它每次都读最新的 UPSTREAM）。
-      upstream: UPSTREAM,
+      // 传**取值器**而不是当次的值（0.7.0-beta.2 修复）。
+      //
+      // 【2026-10-09 真机事故】这里以前传的是 `UPSTREAM` 这个**当次快照**：bridge 起来时宿主还在
+      //   3080，随后宿主换了端口（Desktop 每次启动随机），隧道转发侧因为每次读最新 UPSTREAM 而
+      //   一切正常，**唯独微信事件通道抱着 3080 死循环重连** —— 现象极具迷惑性：手机能开页面、
+      //   bridge-status 显示 online，但任务跑完**一条推送都没有**，日志里只有刷屏的
+      //   `connect ECONNREFUSED 127.0.0.1:3080`。
+      // 现在取值器每次重连都会重新求值，并在打到死端口时主动触发一次上游重发现。
+      upstream: () => currentUpstreamForChannel(),
       cookieOf: harnessCookieOf,
       secret: process.env.DSH_BRIDGE_SECRET || (typeof cfg.bridge_secret === "string" ? cfg.bridge_secret : ""),
       // 免费/付费分层:档位来自账号的生效套餐,App 链接是免费用户越界时的转化入口。

package/runtime/clients/dsh-remote/dsh-events.mjs

@@ -457,6 +457,17 @@ class EventSubscriber extends EventEmitter {
    */
   #cursors = new Map();
 
+  /**
+   * 上一次**连接尝试**用的上游 URL（不是"成功"的那一次）。
+   *
+   * 为什么记"尝试"而不是"成功"：上游端口从 A 换到 B 时，第一轮打 B 必然是失败的
+   * （B 还没起来），若只在成功后才更新，就会每轮都判成"目标变了"而重置退避 ——
+   * 退避彻底失效、变成猛敲 B。记"上次尝试过的目标"才能做到**同一个目标只重置一次**。
+   */
+  #lastConnectUrl = null;
+  /** 上一次成功求值到的上游（getter 抛错/返回空时的回退，保证不会去打空地址）。 */
+  #lastGoodUpstream = null;
+
   #seq = 0;
   #lastFrameAt = 0;
   #authStatus = null;
@@ -465,11 +476,19 @@ class EventSubscriber extends EventEmitter {
 
   constructor(options = {}) {
     super();
-    if (typeof options.upstream !== "string" || options.upstream.trim() === "") {
+    const upstreamGiven = typeof options.upstream === "function"
+      ? true
+      : typeof options.upstream === "string" && options.upstream.trim() !== "";
+    if (!upstreamGiven) {
       throw new TypeError("dsh-events: options.upstream is required (e.g. http://127.0.0.1:3080)");
     }
+    // upstream 允许是**函数**（每次连接时求值）：宿主端口会变（`dsh web --port 0`、
+    // DSH Desktop 每次启动随机端口），写死字符串的话端口一变，本订阅器就会永久打旧端口。
+    const upstreamGetter = typeof options.upstream === "function"
+      ? options.upstream
+      : () => options.upstream;
     this.#opts = {
-      upstream: options.upstream.replace(/\/+$/, ""),
+      upstreamGetter,
       cookie: options.cookie ?? "",
       muxPath: options.muxPath ?? MUX_PATH,
       /** HTTP 路由（默认 `/api/$events/result`）。 */
@@ -631,8 +650,27 @@ class EventSubscriber extends EventEmitter {
     }
   }
 
-  #muxUrl() {
-    const url = new URL(this.#opts.upstream);
+  /**
+   * 当前上游地址（**每次调用都重新求值**，见构造函数里 upstream 可为函数的说明）。
+   *
+   * 求值失败（函数抛错 / 返回空 / 不是合法 URL）时回退到上一次成功用过的地址，
+   * 保证"取不到新地址"永远不会变成"打一个空 URL"。真的没得回退时返回空串，
+   * 由 `#connect()` 如实报错，而不是静默重连到垃圾地址。
+   */
+  #upstream() {
+    let raw;
+    try {
+      raw = this.#opts.upstreamGetter();
+    } catch (error) {
+      this.#log("warn", "upstream getter threw", { error: String(error) });
+      return this.#lastGoodUpstream ?? "";
+    }
+    const value = typeof raw === "string" ? raw.replace(/\/+$/, "") : "";
+    return value || this.#lastGoodUpstream || "";
+  }
+
+  #muxUrl(upstream) {
+    const url = new URL(upstream);
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
     url.pathname = this.#opts.muxPath;
     url.search = "";
@@ -643,16 +681,35 @@ class EventSubscriber extends EventEmitter {
   #connect() {
     if (this.#closed) return;
     this.#state = "connecting";
+    const upstream = this.#upstream();
+    if (upstream === "") {
+      this.#state = "auth-failed";
+      this.#emitAuthError(0, "upstream 不可用（取不到宿主地址）", "ws");
+      return;
+    }
+    // 目标变了 = 宿主换了端口（Desktop 每次启动随机 / `dsh web` 重启到新端口）。
+    // 把退避重置，否则旧目标上累积的长退避会让"换了端口反而更慢连上"（最长要等满 maxMs）。
+    if (upstream !== this.#lastConnectUrl) {
+      if (this.#lastConnectUrl !== null) {
+        this.#log("info", `上游切换 ${this.#lastConnectUrl} → ${upstream}，重连退避已重置`, {
+          from: this.#lastConnectUrl,
+          to: upstream,
+        });
+      }
+      this.#lastConnectUrl = upstream;
+      this.#attempt = 0;
+    }
+    this.#lastGoodUpstream = upstream;
     let url;
     try {
-      url = this.#muxUrl();
+      url = this.#muxUrl(upstream);
     } catch (error) {
       this.#state = "auth-failed";
       this.#emitAuthError(0, `upstream 不是合法 URL: ${String(error)}`, "ws");
       return;
     }
     // Host 显式写成上游 authority（loopback 围栏），Cookie 复用 bridge 已持有的浏览器会话。
-    const headers = { Host: new URL(this.#opts.upstream).host };
+    const headers = { Host: new URL(upstream).host };
     const cookie = this.#cookieValue();
     if (cookie !== "") headers.Cookie = cookie;
 
@@ -1411,7 +1468,8 @@ class EventSubscriber extends EventEmitter {
   async #rpc(method, args, eventId) {
     const rpcId = randomUUID();
     const envelope = { type: "client-request", rpcId, method, payload: { args } };
-    const url = `${this.#opts.upstream}${API_CHANNEL}/${method}`;
+    // 回执/RPC 也走**当前**上游（端口变了就跟着走），不是一个启动时固化的字符串。
+    const url = `${this.#upstream()}${API_CHANNEL}/${method}`;
 
     const timeoutMs = Number(this.#opts.rpcTimeoutMs);
     const budgeted = Number.isFinite(timeoutMs) && timeoutMs > 0;
@@ -1984,7 +2042,7 @@ export function classifyTurnEnd(sessionId, event, at) {
 /**
  * 创建一个订阅器。
  * @param {{
- *   upstream: string,
+ *   upstream: string|(() => string),  // 函数 = 每次连接/每次 RPC 重新求值（宿主端口会变）
  *   cookie?: string|(() => string),
  *   muxPath?: string,
  *   resultPath?: string,

package/runtime/clients/dsh-remote/wechat-runtime.mjs

@@ -340,7 +340,7 @@ export class WeChatRuntime {
   /**
    * @param {{
    *   relayDir: string,
-   *   upstream?: string,              // dsh web 地址,默认 http://127.0.0.1:3080
+   *   upstream?: string|(() => string), // dsh web 地址,默认 http://127.0.0.1:3080;函数=每次重连重新求值
    *   cookieOf?: () => string,        // 读 .harness-cookie.json 的回调(bridge 已有该逻辑)
    *   secret?: string,                // 控制面密钥(bridge_secret);空则控制面拒绝所有请求
    *   logger?: any,
@@ -356,6 +356,16 @@ export class WeChatRuntime {
     if (!opts.relayDir) throw new Error("WeChatRuntime: 缺少 relayDir");
     this.relayDir = opts.relayDir;
     this.upstream = String(opts.upstream || "http://127.0.0.1:3080").replace(/\/+$/, "");
+    /**
+     * 上游地址的**取值器**：恰好是字符串时是常量函数。
+     *
+     * 为什么不让它是个固化字符串：宿主端口会变（`dsh web --port 0`、DSH Desktop 每次启动随机端口），
+     * 而事件订阅器是**长连接** —— 固化字符串的后果是端口一变就永久重连到旧端口。
+     * 【2026-10-09 真机实证】bridge 启动时宿主还是 3080，随后换成 19387；隧道转发侧
+     * （每次都读最新 UPSTREAM）一切正常，唯独微信事件通道死循环刷
+     * `connect ECONNREFUSED 127.0.0.1:3080` —— 手机能开页面，但**任务完成没有任何推送**。
+     */
+    this.upstreamOf = typeof opts.upstream === "function" ? opts.upstream : () => this.upstream;
     this.cookieOf = typeof opts.cookieOf === "function" ? opts.cookieOf : () => "";
     this.secret = String(opts.secret || "");
     this.clock = opts.clock || Date.now;
@@ -1597,7 +1607,8 @@ export class WeChatRuntime {
     // 而且完全静默。现在无论订阅器是新建还是注入,都保证挂上处理器(WeakSet 去重,可重复调用)。
     if (!this.subscriber) {
       this.subscriber = createEventSubscriber({
-        upstream: this.upstream,
+        // 传**取值器**而不是当次的值：见构造函数里 upstreamOf 的说明（端口变了要能跟上）。
+        upstream: () => this.upstreamOf(),
         cookie: () => this.cookieOf(),
         follow: true,
         log: (level, message, meta) => {

package/runtime/dsh-setup.mjs

@@ -173,6 +173,12 @@ function printHelp() {
   dsh-remote doctor       一条命令自检「为什么连不上」（只读；含上游/进程/微信/日志尾部）
   dsh-remote --help       显示本用法（等同 dsh-remote help）
 
+目标 profile（默认 Web 版）:
+  dsh-remote --profile desktop    装进 DeepSeek Harness **桌面端**的插件目录
+                                  （~/.dsh/profiles/desktop；装前请先完全退出桌面应用）
+  桌面端也可以在应用内「插件」页直接安装 dsh-remote-web —— 那是官方路径，无需退出。
+  ⚠️ 桌面端与 Web 版共享 ~/.dsh（会话/设置/凭据），但**插件互相隔离**，两边要各自安装。
+
 自建模式（可选）:
   dsh-remote setup --server wss://你的域名:端口 --key 访问密钥
 
@@ -239,19 +245,109 @@ function resolveExecutable(p) {
   } catch { return null; }
 }
 
+/**
+ * 宿主是否跑在 **Electron 的 Node 模式**下（DeepSeek Harness 桌面端的 Host 就是）。
+ *
+ * 桌面端 `process.execPath` 是 **Electron 应用二进制**而不是 node：不带
+ * `ELECTRON_RUN_AS_NODE=1` 直接拿它跑脚本，得到的不是「跑脚本的 node」，而是
+ * **又启动一个桌面端应用实例**。自启动服务是系统在应用退出后拉起的，踩到这里
+ * 的表现是「服务登记成功、进程秒退、bridge 永远起不来」，与 0.6.15 那次端口事故
+ * 一样难排查 —— 所以必须在**写服务定义时**就把变量带上。
+ */
+const IS_ELECTRON_HOST = Boolean(process.versions && process.versions.electron);
+
+/**
+ * DeepSeek Harness **桌面端自带 Node** 的稳定落点候选。
+ *
+ * 为什么需要：桌面端主打的正是**机器上没有系统 node** 的用户；而自启动服务要活过
+ * 桌面端的退出、甚至升级/重装（`.app` 路径会变、可能被换掉）。桌面端把自带运行时装在
+ * **用户目录** `~/.dsh/dsh-runtimes/…`，它不随应用包更新而移动 —— 所以只要它存在，
+ * 就该优先于任何指向 `.app` 内部的路径。
+ *
+ * 目录布局随桌面端版本演进（可能多套一层 runtime/node），故按多个候选探测；
+ * `resolveExecutable()` 会过滤掉不存在的路径，多列无害。
+ * @returns {string[]} 候选可执行文件绝对路径（可能都不存在）。
+ */
+function desktopRuntimeNodeCandidates() {
+  const isWin = process.platform === "win32";
+  const exe = isWin ? "node.exe" : "node";
+  const out = [];
+  // ① 稳定落点：装在**用户目录**，桌面端升级/重装都不动它。
+  //    ⚠️ 真实布局是 `dependencies/node/bin/<exe>`（2026-10-07 拆官方 0.2.0-rc.2 DMG 实测：
+  //    `…/Resources/runtime/primary-runtime/dependencies/node/bin/node` → Node v24.21.0）。
+  //    其余几个是兼容不同版本的兜底；resolveExecutable() 会过滤掉不存在的路径，多列无害。
+  const roots = [
+    process.env.DSH_DESKTOP_RUNTIME_DIR || "",
+    path.join(os.homedir(), ".dsh", "dsh-runtimes", "dsh-primary-runtime"),
+    path.join(os.homedir(), ".dsh", "dsh-runtimes", "primary-runtime"),
+  ].filter(Boolean);
+  for (const root of roots) {
+    out.push(
+      path.join(root, "dependencies", "node", "bin", exe),
+      path.join(root, "bin", exe),
+      path.join(root, "node", "bin", exe),
+      path.join(root, "runtime", "bin", exe),
+    );
+  }
+  // ② 应用自己把自带 node 的路径交给子进程（其 `runtime/bin/node` shim 就是靠这个变量）——
+  //    平台无关，且是"应用自己说的"，比我们猜路径可靠。
+  if (process.env.DSH_DESKTOP_NODE_EXECUTABLE) out.push(process.env.DSH_DESKTOP_NODE_EXECUTABLE);
+  // ③ 最后才是指向应用包内部的绝对路径：它是**真实存在的 node**，但会随桌面端更新换路径，
+  //    所以排在稳定落点之后（自启动服务登记它属于"聊胜于无"，好过登记 Electron 本体）。
+  if (isWin) {
+    const local = process.env.LOCALAPPDATA || "";
+    if (local) out.push(path.join(local, "Programs", "DeepSeek Harness", "resources", "runtime", "primary-runtime", "dependencies", "node", exe));
+  } else {
+    out.push(
+      "/Applications/DeepSeek Harness.app/Contents/Resources/runtime/primary-runtime/dependencies/node/bin/node",
+      "/Applications/DSH Desktop.app/Contents/Resources/runtime/primary-runtime/dependencies/node/bin/node",
+    );
+  }
+  return out;
+}
+
 function preferredNode() {
+  // 先归一化"自己的可执行文件"，用来判断最终选中的解释器是否就是 Electron 本体。
+  const selfReal = resolveExecutable(process.execPath) || process.execPath;
   const candidates = [
     process.env.DSH_SETUP_NODE20 || "",
     process.env.DSH_SETUP_NODE || "",
+    // 桌面端（Electron 宿主）：**真实 node 优先**。服务要活过桌面应用的退出与更新
+    //（.app 路径会变、可能被换掉），登记一个真实 node 才稳；找不到才回落 Electron 自身，
+    // 那时由 SERVICE_NODE_ENV 补上 ELECTRON_RUN_AS_NODE=1 把它变成 node。
+    ...(IS_ELECTRON_HOST
+      ? [
+          // 桌面端自带 Node 的**稳定**落点：装在用户目录（~/.dsh/dsh-runtimes/…），
+          // 桌面端升级/重装都不动它 —— 比 .app 内部路径更该登记进自启动服务。
+          ...desktopRuntimeNodeCandidates(),
+          "/opt/homebrew/opt/node@20/bin/node", "/usr/local/opt/node@20/bin/node", "/opt/homebrew/bin/node", "/usr/local/bin/node",
+        ]
+      : []),
     process.execPath
   ].filter(Boolean);
   for (const p of candidates) {
     const real = resolveExecutable(p);
-    if (real) return real;
-  }
-  return process.execPath;
+    if (real) return { bin: real, electron: IS_ELECTRON_HOST && real === selfReal };
+  }
+  return { bin: process.execPath, electron: IS_ELECTRON_HOST };
+}
+const INTERPRETER = preferredNode();
+const NODE_BIN = INTERPRETER.bin;
+/** 解释器是 Electron 二进制时必须注入的变量（真实 node 时为空对象，行为与本改动前一致）。 */
+const SERVICE_NODE_ENV = INTERPRETER.electron ? { ELECTRON_RUN_AS_NODE: "1" } : {};
+/** plist `EnvironmentVariables` 里追加的条目（真实 node 时为空串 → 模板逐字节不变）。 */
+const SERVICE_NODE_ENV_PLIST = Object.entries(SERVICE_NODE_ENV)
+  .map(([k, v]) => `<key>${k}</key><string>${v}</string>`).join("");
+/** systemd unit 里追加的 `Environment=` 行（真实 node 时为空串 → 模板逐字节不变）。 */
+const SERVICE_NODE_ENV_UNIT = Object.entries(SERVICE_NODE_ENV)
+  .map(([k, v]) => `Environment=${k}=${v}\n`).join("");
+/**
+ * 供**子进程 spawn** 用的环境（继承当前环境 + 解释器变量）。
+ * 本文件里凡是用 NODE_BIN 拉起子进程的地方都要带上它。
+ */
+function nodeEnv(extra) {
+  return { ...process.env, ...SERVICE_NODE_ENV, ...(extra || {}) };
 }
-const NODE_BIN = preferredNode();
 
 /**
  * 自启动服务里注入的 PATH。
@@ -516,10 +612,17 @@ function writeWinHiddenLauncher(node, setup) {
   const vbsPath = winHiddenLauncherPath();
   const commandLine = `"${node}" "${setup}" run`; // 真正要执行的命令行
   const literal = commandLine.replace(/"/g, '""'); // 嵌进 VBS 字符串字面量后
+  // 解释器是 Electron（桌面端宿主且机器上没有真实 node）时，必须先设 ELECTRON_RUN_AS_NODE=1：
+  // 否则 wscript 拉起的不是 bridge 守护，而是**又开一个桌面端应用**。
+  // VBScript 侧的写法是往进程环境里塞，再 Run（不能像 shell 那样内联前缀）。
+  const envLines = Object.entries(SERVICE_NODE_ENV).map(([k, v]) => `sh.Environment("PROCESS")("${k}") = "${v}"`);
+  const runLines = envLines.length > 0
+    ? [`Set sh = CreateObject("WScript.Shell")`, ...envLines, `sh.Run "${literal}", 0, False`]
+    : [`CreateObject("WScript.Shell").Run "${literal}", 0, False`];
   const src = [
     "' dsh-remote 自动生成（勿手改，重装会覆盖）",
     "' 隐藏启动 bridge 守护：窗口样式 0 = 不显示窗口；False = 不等待，node 成为独立进程。",
-    `CreateObject("WScript.Shell").Run "${literal}", 0, False`,
+    ...runLines,
     "",
   ].join("\r\n");
   fs.mkdirSync(CONFIG_DIR, { recursive: true });
@@ -532,6 +635,12 @@ function writeWindowsTask() {
   const setup = runtimeSetupPath();
   // 首选 wscript 包装（无黑窗）；写不了 .vbs 就退回直接启动（有窗，但保底能自启）
   let direct = `"${node}" "${setup}" run`;
+  // 解释器是 Electron 时，直接启动这条路没有 .vbs 可以设环境变量，只能借 cmd 的 `set`
+  // （schtasks 的 /TR 只接受一条命令行，不能内联 env）。
+  if (Object.keys(SERVICE_NODE_ENV).length > 0) {
+    const sets = Object.entries(SERVICE_NODE_ENV).map(([k, v]) => `set ${k}=${v}`).join(" && ");
+    direct = `cmd.exe /c ${sets} && "${node}" "${setup}" run`;
+  }
   let tr = direct;
   let hidden = false;
   try {
@@ -599,7 +708,7 @@ function writeAutostartFile() {
   <key>LimitLoadToSessionType</key><array><string>Aqua</string><string>Background</string></array>
   <key>StandardOutPath</key><string>${path.join(CONFIG_DIR, ".dsh-bridge.log")}</string>
   <key>StandardErrorPath</key><string>${path.join(CONFIG_DIR, ".dsh-bridge.log")}</string>
-  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${SERVICE_PATH}</string><key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${INSTALL_SOURCE}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${INSTALL_VERSION}</string></dict>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${SERVICE_PATH}</string>${SERVICE_NODE_ENV_PLIST}<key>DSH_BRIDGE_INSTALL_SOURCE</key><string>${INSTALL_SOURCE}</string><key>DSH_BRIDGE_INSTALL_VERSION</key><string>${INSTALL_VERSION}</string></dict>
 </dict></plist>`;
     // ~/Library/LaunchAgents 在全新账户/精简系统上可能不存在,必须先建目录,
     // 否则 writeFileSync 抛 ENOENT 直接把安装流程打断(用户反馈里也踩过类似的路径问题)。
@@ -615,7 +724,7 @@ function writeAutostartFile() {
   if (process.platform === "linux") {
     const dir = path.join(os.homedir(), ".config/systemd/user");
     fs.mkdirSync(dir, { recursive: true });
-    const unit = `[Unit]\nDescription=dsh-remote bridge (auto-starts with dsh web)\n\n[Service]\nExecStart=${runCmd}\nRestart=on-failure\nRestartSec=5\nEnvironment=PATH=${SERVICE_PATH}\nEnvironment=DSH_BRIDGE_INSTALL_SOURCE=${INSTALL_SOURCE}\nEnvironment=DSH_BRIDGE_INSTALL_VERSION=${INSTALL_VERSION}\n\n[Install]\nWantedBy=default.target\n`;
+    const unit = `[Unit]\nDescription=dsh-remote bridge (auto-starts with dsh web)\n\n[Service]\nExecStart=${runCmd}\nRestart=on-failure\nRestartSec=5\nEnvironment=PATH=${SERVICE_PATH}\n${SERVICE_NODE_ENV_UNIT}Environment=DSH_BRIDGE_INSTALL_SOURCE=${INSTALL_SOURCE}\nEnvironment=DSH_BRIDGE_INSTALL_VERSION=${INSTALL_VERSION}\n\n[Install]\nWantedBy=default.target\n`;
     const unitPath = autostartFilePath();
     fs.writeFileSync(unitPath, unit);
     return unitPath; // 路径在最终汇总里统一展示
@@ -673,7 +782,7 @@ function spawnDetachedBridge() {
     const child = spawn(NODE_BIN, [runtimeSetupPath(), "run"], {
       detached: true,
       stdio: ["ignore", out, out],
-      env: process.env,
+      env: nodeEnv(),
       // Windows 上 detached 即 DETACHED_PROCESS：子进程**不继承父控制台**，
       // 控制台程序（node.exe）会因此拿到一个**全新的可见窗口**。
       // 必须显式 windowsHide 才会带上 CREATE_NO_WINDOW（POSIX 上该选项被忽略）。
@@ -894,14 +1003,63 @@ async function isDshWebUp(timeoutMs = 1200) {
   return upstreamReachable(after, timeoutMs);
 }
 
+/** 已知的 DSH profile 名（`--profile web` / `--profile desktop` 这种写法要能用）。 */
+const KNOWN_PROFILE_NAMES = ["web", "desktop"];
+/** profile 名 → 目录（与 dsh 自己的 `$DSH_HOME/profiles/<name>` 口径一致）。 */
+function profileDirOfName(name) {
+  return path.join(os.homedir(), ".dsh", "profiles", name);
+}
+/** 目标目录是否就是**桌面端**保留的 profile（由 Electron 应用独占管理）。 */
+function isDesktopProfileDir(dir) {
+  return path.resolve(dir) === path.resolve(profileDirOfName("desktop"));
+}
+
 /**
- * 解析 dsh web profile 目录（安装与插件管理共用同一口径）。
+ * 解析目标 profile 目录（安装与插件管理共用同一口径）。
+ *
+ * 三种写法都支持：
+ *   · `--profile web` / `--profile desktop` → `~/.dsh/profiles/<name>`
+ *     （新增：DeepSeek Harness 桌面端的 profile 就叫 `desktop`）
+ *   · `--profile <任意路径>`                → 原样当目录用（老行为，保持不变）
+ *   · `DSH_PROFILE_DIR` 环境变量            → 与 `--profile` 同口径
+ * 缺省仍是 Web 版 profile，行为与改动前完全一致。
  */
 function resolveProfileDir(argv = []) {
   const i = argv.indexOf("--profile");
-  return i > -1 && argv[i + 1]
-    ? argv[i + 1]
-    : process.env.DSH_PROFILE_DIR || path.join(os.homedir(), ".dsh", "profiles", "web");
+  const explicit = i > -1 && argv[i + 1] ? argv[i + 1] : process.env.DSH_PROFILE_DIR;
+  if (!explicit) return profileDirOfName("web");
+  if (KNOWN_PROFILE_NAMES.includes(explicit)) return profileDirOfName(explicit);
+  return explicit;
+}
+
+/**
+ * 从任意 argv 里挑出 profile 选择参数。
+ *
+ * 为什么需要：安装主流程 `setup()` 的 argv 里可能带 `--profile desktop`，但它内部调用
+ * `pluginCmd()` 时原本传的是空数组 —— 于是"指定 desktop profile"会被静默忽略、
+ * 插件仍然装进 Web 版 profile（桌面端用户装了却看不到面板，且极难自查）。
+ */
+function profileArgvOf(argv = []) {
+  const i = argv.indexOf("--profile");
+  return i > -1 && argv[i + 1] ? ["--profile", argv[i + 1]] : [];
+}
+
+/**
+ * 目标 profile 是桌面端时给出的前置提醒（安装前调用）。
+ *
+ * 桌面端的 `profiles/desktop` 由 Electron 应用**独占**：应用运行时它会持有 profile 写锁，
+ * 且运行中的进程不会重新装载我们刚写进去的插件。所以要么完全退出应用再装，要么
+ * 直接在应用内的「插件」页安装（那是官方路径，无需退出）。
+ * 这里只做提醒，不阻断 —— 用户可能正是在"应用已退出"的状态下跑安装器。
+ */
+function warnIfDesktopProfile(dir) {
+  if (!isDesktopProfileDir(dir)) return;
+  console.log("");
+  console.log("ℹ️ 目标 profile 是 DeepSeek Harness **桌面端**的保留 profile（~/.dsh/profiles/desktop）。");
+  console.log("   · 请先**完全退出** DeepSeek Harness 应用再安装（应用独占该 profile，运行中写入不会被装载）；");
+  console.log("   · 装完后重新打开应用即可。更省事的做法是在应用内「插件」页直接安装 dsh-remote-web；");
+  console.log("   · 桌面端与 Web 版共用 ~/.dsh 下的会话/设置/凭据，但**插件互相隔离**，两边需要各自安装。");
+  console.log("");
 }
 
 /**
@@ -1032,7 +1190,7 @@ logLine("已重新拉起 dsh web：pid=" + String(child.pid));
   try {
     fs.mkdirSync(CONFIG_DIR, { recursive: true });
     fs.writeFileSync(helper, src);
-    const child = spawn(NODE_BIN, [helper], { detached: true, stdio: "ignore", cwd: os.homedir(), windowsHide: true });
+    const child = spawn(NODE_BIN, [helper], { detached: true, stdio: "ignore", cwd: os.homedir(), windowsHide: true, env: nodeEnv() });
     child.on("error", () => { /* 有 error 监听：绝不能把宿主/安装器打挂 */ });
     child.unref();
     return { ok: true, how: "Windows 重启助手（原命令行自拉起）" };
@@ -1357,7 +1515,7 @@ async function runBridge() {
       // 只有它能让我们在停 bridge 之前请它跑完退出钩子（notifystop）—— 见 stopChildGracefully。
       bridgeProc = spawn(NODE_BIN,
         [path.join(THIS_DIR, "clients/dsh-remote/dsh-bridge.mjs")],
-        { env: childEnv, stdio: ["inherit", "inherit", "inherit", "ipc"] });
+        { env: nodeEnv(childEnv), stdio: ["inherit", "inherit", "inherit", "ipc"] });
       bridgeProc.on("exit", () => {
         removePidFile(BRIDGE_PID_FILE);
         console.log("[dsh-remote] bridge 退出，等待重启...");
@@ -1480,7 +1638,10 @@ async function setup(argv) {
   let pluginResult = null;
   if (!noPlugin) {
     try {
-      pluginResult = await pluginCmd([]);
+      // ⚠️ 必须把 `--profile` **透传下去**：否则 `--profile desktop`（桌面端）会被静默忽略，
+      // 插件装进 Web 版 profile，而用户面对的是桌面端 —— 面板永远不出现。
+      warnIfDesktopProfile(resolveProfileDir(argv));
+      pluginResult = await pluginCmd(profileArgvOf(argv));
     } catch (e) {
       console.warn(`⚠️ 插件安装未完成：${e.message}`);
     }
@@ -2178,7 +2339,7 @@ function probePluginResolve(profileDir) {
     "}));",
   ].join("\n");
   try {
-    const r = spawnSync(process.execPath, ["-e", script], { encoding: "utf8", timeout: 30_000, windowsHide: true });
+    const r = spawnSync(process.execPath, ["-e", script], { encoding: "utf8", timeout: 30_000, windowsHide: true, env: nodeEnv() });
     if (r.error) return { ok: false, reason: `无法启动解析探测进程：${r.error.message}` };
     if (r.status !== 0) {
       const line = String(r.stderr || "").split("\n").find((l) => /MODULE_NOT_FOUND|ERR_|Error/.test(l)) || "解析失败";
@@ -2452,8 +2613,19 @@ async function pluginCmd(argv) {
   const pluginDir = path.join(THIS_DIR, "packages", PLUGIN_ID);
 
   if (!fs.existsSync(pkgFile) || !fs.existsSync(patchFile)) {
-    console.error(`❌ 未找到 dsh web profile（${profileDir}）。`);
-    console.error("   请先安装 DeepSeek Harness（npx @deepseek-ai/dsh web）并初始化默认 profile。");
+    console.error(`❌ 未找到 profile（${profileDir}）。`);
+    if (isDesktopProfileDir(profileDir)) {
+      // 桌面端 profile 由 Electron 应用**自己初始化**：npm 版 `dsh` 明确拒绝管理它
+      // （apps/cli 的 rejectElectronProfile），所以 Web 版那句 "npx @deepseek-ai/dsh web"
+      // 在桌面端**不成立**，照抄只会让用户白折腾。这里必须给桌面端专属的三步。
+      console.error("   桌面端 profile 由 DeepSeek Harness 应用自己创建，不能像 Web 版那样用 npx 造出来：");
+      console.error("   ① 先启动一次 DeepSeek Harness 应用，让它初始化该 profile；");
+      console.error("   ② 完全退出应用（应用独占该 profile，运行中安装不会被装载）；");
+      console.error("   ③ 再执行本次安装：dsh-remote --profile desktop");
+      console.error("   更省事的官方路径：直接在应用内「插件」页安装 dsh-remote-web。");
+    } else {
+      console.error("   请先安装 DeepSeek Harness（npx @deepseek-ai/dsh web）并初始化默认 profile。");
+    }
     process.exit(1);
   }
   if (!fs.existsSync(pluginDir)) {