@mrrisega/dsh-remote 0.4.6 → 0.4.8

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

@@ -47,7 +47,8 @@ import WebSocket from "ws";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { randomBytes, generateKeyPairSync } from "node:crypto";
+import { execSync } from "node:child_process";
+import { randomBytes, generateKeyPairSync, createHash } from "node:crypto";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { gzip as gzipCb } from "node:zlib";
@@ -80,6 +81,46 @@ const PHONE = process.env.DSH_BRIDGE_PHONE || EMAIL;
 const PASSWORD = process.env.DSH_BRIDGE_PASSWORD || "";
 const TOKEN = process.env.DSH_BRIDGE_TOKEN || "";
 
+// ---------- 本机稳定指纹(同机重装识别;供服务端自动顶替旧设备) ----------
+
+/** 读取与安装无关的机器级唯一值:macOS IOPlatformUUID / Linux machine-id。 */
+function machineUniqueId() {
+  if (process.env.DSH_BRIDGE_MACHINE_FP) return String(process.env.DSH_BRIDGE_MACHINE_FP).slice(0, 64);
+  if (process.platform === "darwin") {
+    try {
+      const out = execSync("ioreg -rd1 -c IOPlatformExpertDevice", { encoding: "utf8", timeout: 5000 });
+      const m = /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(out);
+      if (m && m[1]) return m[1];
+    } catch { /* 兜底 */ }
+  } else if (process.platform === "linux") {
+    for (const f of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+      try {
+        const s = fs.readFileSync(f, "utf8").trim();
+        if (s) return s;
+      } catch { /* 继续 */ }
+    }
+  }
+  return ""; // 读不到(如容器) → 回退宿主名指纹
+}
+/** 稳定指纹:机器唯一值哈希;同机卸载重装后不变。 */
+function machineFingerprint() {
+  const base = machineUniqueId() || `${os.hostname()}|${os.platform()}`;
+  return createHash("sha256").update(`dsh-remote/machine/v1:${base}`).digest("hex").slice(0, 32);
+}
+const MACHINE_FP = machineFingerprint();
+
+/** 绑定/登录失败提示文件:供 dsh web 插件面板读取并展示(如“注册失败,已达到上限”)。 */
+const BIND_ERROR_FILE = path.join(path.dirname(CONFIG_PATH), ".bind-error.json");
+function persistBindError(payload) {
+  try {
+    fs.mkdirSync(path.dirname(BIND_ERROR_FILE), { recursive: true });
+    fs.writeFileSync(BIND_ERROR_FILE, JSON.stringify({ ...payload, at: Date.now() }, null, 2), { mode: 0o600 });
+  } catch { /* 非关键 */ }
+}
+function clearBindError() {
+  try { fs.rmSync(BIND_ERROR_FILE, { force: true }); } catch { /* 非关键 */ }
+}
+
 // ---------- 稳定设备身份(.dsh-config.json) ----------
 
 function loadLocalConfig() {
@@ -575,25 +616,36 @@ async function registerDeviceInAccount(token) {
     const r = await fetch(API_BASE + "/api/devices", {
       method: "POST",
       headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
-      body: JSON.stringify({ device_id: DEVICE_ID, device_name: os.hostname() || "dsh-bridge", pub_key: pubKey })
+      body: JSON.stringify({
+        device_id: DEVICE_ID,
+        device_name: os.hostname() || "dsh-bridge",
+        pub_key: pubKey,
+        machine_fp: MACHINE_FP // v6 同机识别:服务端据此自动顶替旧设备(重装不再被设备数卡死)
+      })
     });
     const d = await r.json().catch(() => ({}));
     if (r.status === 201 || r.status === 200) {
+      clearBindError();
       console.log(`[bridge] ✅ 设备已登记到账号: ${DEVICE_ID}`);
       return;
     }
     if (r.status === 409) {
       const code = d.error?.code || "";
       if (code === "device_limit_exceeded") {
-        console.error(`[bridge] 设备数已达上限: ${d.error?.message || "当前套餐最多绑定 1 台设备"}`);
-        console.error("   请在手机端设备管理或后台移除旧设备后重启。");
+        const msg = d.error?.message || "当前套餐最多绑定 1 台设备";
+        persistBindError({ code, message: msg });
+        console.error(`[bridge] 设备数已达上限: ${msg}`);
+        console.error("   同机重装会自动顶替旧设备;仍失败请到手机端设备管理解绑旧设备后重启(免费每月可解绑 3 次)。");
       } else {
+        persistBindError({ code, status: 409, message: d.error?.message || "绑定冲突" });
         console.error(`[bridge] 设备 ${DEVICE_ID} 绑定失败(${code || 409}): ${d.error?.message || "未知错误"}`);
       }
       process.exit(1);
     }
+    persistBindError({ code: d.error?.code || `http_${r.status}`, status: r.status, message: d.error?.message || "设备登记失败" });
     console.warn(`[bridge] 设备登记失败(${r.status}): ${d.error?.message || "未知错误"}(手机端设备列表可能看不到本设备)`);
   } catch (e) {
+    persistBindError({ code: "api_unreachable", message: `无法连接账号 API: ${e.message}` });
     console.warn(`[bridge] 无法连接账号 API ${API_BASE}: ${e.message}(手机端设备列表可能看不到本设备)`);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "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-ui/README.md

@@ -1,4 +1,13 @@
-# dsh-remote-ui — dsh web 远程控制插件
+# dsh-remote-ui — 公网远程控制 dsh web 的插件
+
+> **给 DeepSeek Harness（dsh web）一个「随时随地」的公网入口。**
+> 安装后在 dsh web 的设置页登录账号，即得到一个专属的**加密远程地址**：人在办公室外、
+> 用手机流量或任意网络打开它，都能像坐在电脑前一样操作 dsh——继续对话、看工具执行、
+> 审批授权、改设置。**不要求手机和电脑在同一 WiFi/局域网**，也不需要公网 IP、
+> 路由器映射或自己搭服务器，开箱即用、全程加密。
+> 懂技术的用户也可以把服务部署到自己的服务器上，数据与流量完全自控（普通用户无需关心）。
+
+以下为面向开发者/维护者的实现说明：
 
 Embeds the dsh-remote configuration UI into dsh web itself (the "everything is a
 plugin" model):

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

@@ -713,7 +713,10 @@ window.__ModuleLoader__.load({
         post("/dsh-remote/self/uninstall", {}).then(function (b) {
           if (b && b.ok) {
             setArmed(false);
-            setSelfMsg({ kind: "ok", text: "已移除插件引用与本地文件。请重启 dsh web：插件将完全卸载（本栏目也会消失）。之后如需重新安装，直接在插件市场再次安装即可。" });
+            // 优先展示服务端 detail（含 bridge 自启动/配置目录的逐项清理结果与重启提示）；
+            // 兜底文案同样说明 bridge 自启动服务与本地配置目录会一并移除/清空
+            var detail = b && b.detail ? String(b.detail) : "";
+            setSelfMsg({ kind: "ok", text: detail || "已彻底卸载：插件引用、bridge 自启动服务与本地配置目录（账号/密钥/运行时等）已一并移除并清空。请重启 dsh web 后完全生效（本栏目将消失）；如需再次使用，在插件市场重新安装即可。" });
           } else {
             setArmed(false);
             setSelfMsg({ kind: "err", text: "卸载失败：" + ((b && (b.error || b.detail)) || "未知错误") });
@@ -762,7 +765,7 @@ window.__ModuleLoader__.load({
         log ? h("div", { className: "dru-up-log", title: "更新日志（尾部）" }, log) : null,
         selfMsg ? h("div", { className: "dru-msg dru-msg-" + selfMsg.kind }, selfMsg.text) : null,
         h("div", { className: "dru-hint", style: { marginTop: 8 } },
-          armed ? "卸载会移除插件引用与本地文件；远程控制用的桌面 bridge 与数据目录保留，可随时重新安装。" :
+          armed ? "⚠ 再次点击后即开始彻底卸载：① 移除 dsh web 配置中的插件引用与本地文件；② 停止并移除 bridge 自启动服务（macOS com.dshremote.bridge / Linux dsh-bridge）并结束残留进程；③ 清空本地配置目录（~/.dsh-remote：账号、设备密钥、固化运行时等）。此操作不可撤销，如需再次使用请在插件市场重新安装。" :
             "插件市场没有更新/卸载按钮（dsh 官方市场暂不提供），本卡片即官方管理入口：检测新版、一键在线更新、彻底卸载都在这里完成。")
       );
     }
@@ -1174,7 +1177,16 @@ window.__ModuleLoader__.load({
                 : h("button", { type: "button", className: "dru-btn dru-btn-danger", disabled: busy !== "", onClick: function () { toggleBridge(false); } }, busy === "stop" ? "停止中…" : "停止 bridge")
             ),
             h("div", { className: "dru-meta" }, st && st.config && st.config.deviceId ? "设备 ID：" + st.config.deviceId : "设备 ID：生成中"),
-            h("div", { className: "dru-meta" }, st ? (st.service && st.service.plistExists ? "自启动服务已安装" : "自启动服务未安装（启动时自动创建）") : "")
+            h("div", { className: "dru-meta" }, st ? (st.service && st.service.plistExists ? "自启动服务已安装" : "自启动服务未安装（启动时自动创建）") : ""),
+            st && st.service && st.service.bindError
+              ? h("div", { className: "dru-msg dru-msg-err", style: { marginTop: 8 } },
+                  "⚠️ 设备注册失败：" + (st.service.bindError.message || "未说明原因"),
+                  h("div", { className: "dru-hint", style: { marginTop: 4 } },
+                    st.service.bindError.code === "device_limit_exceeded"
+                      ? "已达本套餐设备数上限。若是同一台电脑重装，稍等片刻会自动顶替旧设备；仍未恢复请在手机端「设备管理」解绑旧设备（免费用户每月可解绑 3 次）后，回到这里点「启动 bridge」。"
+                      : "请确认网络与账号状态后重试；仍未解决可点下方「彻底卸载」后重新安装。")
+                )
+              : null
           ),
           // 关于 dsh-remote（开源项目说明卡片）
           card("📖 关于 dsh-remote", [

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

@@ -5,13 +5,15 @@
 //   - 查询/启停 bridge（launchctl，plist 缺失时自动生成，逻辑与 dsh-setup.mjs 一致）
 //   - 代理 relay API（captcha / register / login / public-config），直连、不走系统代理
 //   - 自管理 self*（版本可见 / 新版检测 / 一键在线更新 / 彻底卸载）：插件市场没有更新卸载按钮，
-//     面板内即官方管理入口；更新=后台 npx @mrrisega/dsh-remote@latest（幂等补齐运行环境并重启 bridge）
+//     面板内即官方管理入口；更新=后台 npx @mrrisega/dsh-remote@latest（幂等补齐运行环境并重启 bridge）；
+//     彻底卸载=profile 插件清理（uninstallSelf）+ 运行时清理（uninstallRuntime：停 bridge 自启动 /
+//     删 plist|unit / 杀残留进程 / 清空配置目录 ~/.dsh-remote），0.4.7 起回归真正「未安装」状态
 //   - 运行时自愈：缺运行环境自动后台安装、登录后自动拉起 bridge（0.4.2 起）
 //   - 0.1.2+ ?token 浏览器鉴权会话代持（0.4.1 起）
 //
 // 不依赖任何第三方包：只使用 node 内置模块与 cordis 注入的 webServer 服务。
 import { readFileSync, writeFileSync, mkdirSync, existsSync, realpathSync, accessSync, chmodSync, openSync, closeSync, rmSync, constants as fsConstants } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, sep } from "node:path";
 import { execSync, spawn } from "node:child_process";
 import { homedir, hostname, platform } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -231,6 +233,7 @@ function setCookieOf(res) {
 }
 
 async function mintHarnessCookie(ctx, relayDir) {
+  if (UNINSTALLED_DIRS.has(relayDir)) return false; // 已彻底卸载：不再代持会话、不再重建配置目录
   try {
     const port = ctx.webServer?.port;
     if (!port) return false;
@@ -248,6 +251,8 @@ async function mintHarnessCookie(ctx, relayDir) {
     const res = await fetch(tokenUrl, { redirect: "manual", signal: AbortSignal.timeout(6000) });
     const cookie = setCookieOf(res).split(";")[0].trim();
     if (!cookie || !cookie.startsWith("dsh-auth-")) return false;
+    // 竞态兜底：fetch 期间用户点击了「彻底卸载」→ 不得重建已被清空的配置目录
+    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 });
@@ -366,6 +371,7 @@ function appendLogLine(relayDir, name, line) {
  * 注意：默认优先官方源——镜像(npmmirror)可能滞后于刚发布的版本，装到旧版会把
  * 已被 0.4.5 移除的“用户 include”重新写回 profile（历史上造成 dsh web 重复 ID 崩溃）。 */
 function ensureRuntime(relayDir) {
+  if (UNINSTALLED_DIRS.has(relayDir)) return false; // 已彻底卸载：不再自动安装运行环境
   if (existsSync(join(relayDir, "dsh-setup.mjs"))) return true;
   const marker = join(relayDir, PROVISION_MARKER);
   if (existsSync(marker)) return false; // 正在安装中
@@ -422,6 +428,10 @@ function writeAutostartFile(relayDir) {
 
 /** 启动 bridge：确保 plist 存在 → launchctl bootstrap（回退 load -w）。 */
 function startBridge(relayDir) {
+  if (UNINSTALLED_DIRS.has(relayDir)) {
+    // 已彻底卸载：面板/自愈在重启前可能仍在内存中，禁止再把自启动与 plist 拉回来
+    return { ok: false, status: "uninstalled", detail: "插件已彻底卸载，重启 dsh web 后生效" };
+  }
   const plistPath = launchAgentPath();
   if (!plistPath) return { ok: false, status: "unsupported", detail: "仅支持 macOS" };
   if (!existsSync(plistPath)) writeAutostartFile(relayDir);
@@ -444,6 +454,7 @@ function scheduleRuntime(relayDir) {
   let done = false;
   const iv = setInterval(() => {
     if (done) { clearInterval(iv); return; }
+    if (UNINSTALLED_DIRS.has(relayDir)) { done = true; clearInterval(iv); return; } // 已彻底卸载：自愈 watcher 停摆
     try {
       const cfg = loadConfig(relayDir);
       const hasAcct = Boolean((cfg.phone || cfg.email) && cfg.password) || Boolean(cfg.local_key);
@@ -471,6 +482,112 @@ function stopBridge() {
   return { ok: !st.running, status: st.running ? "failed" : "stopped", pid: null, detail: st.running ? (r.stderr || "停止失败").trim() : void 0 };
 }
 
+// ---------- 彻底卸载：bridge 自启动 / 残留进程 / 配置目录 ----------
+
+/**
+ * 已执行「彻底卸载」的 relayDir 集合。卸载动作本身不改代码，但 dsh web 重启前本插件仍在内存中：
+ * 自愈调度（scheduleRuntime/ensureRuntime/startBridge）与浏览器会话代持（mintHarnessCookie）
+ * 若继续执行，会把刚清空的配置目录 / 自启动服务重新拉起来——故卸载后本进程内一律停摆，
+ * 直到 dsh web 重启（profile 引用已移除，插件整体不再加载）或重新激活（apply 时清除）。
+ */
+const UNINSTALLED_DIRS = new Set();
+
+/** 标记某 relayDir 已完成彻底卸载（其后续自愈/代持调度全部停摆）。 */
+function markUninstalled(relayDir) {
+  if (relayDir) UNINSTALLED_DIRS.add(relayDir);
+}
+
+/**
+ * 彻底卸载 —— 「运行时/bridge」部分：把本机 dsh-remote 运行时回归到未安装状态。
+ * 执行顺序（每步独立 try/catch，单项失败不致命，不影响后续步骤；结果以标志位返回）：
+ *   1) 停掉自启动服务并移除自启动文件：macOS launchctl bootout com.dshremote.bridge +
+ *      删 ~/Library/LaunchAgents/com.dshremote.bridge.plist；Linux systemctl --user
+ *      stop/disable dsh-bridge（+ 删 ~/.config/systemd/user/dsh-bridge.service）。
+ *      ⚠ 必须先停服务再删配置目录：否则 launchd KeepAlive / systemd Restart 会立刻
+ *      重启一个「指向已被删除文件」的进程；
+ *   2) 杀掉仍存活的手动 watcher/bridge 进程（launchd/systemd 托管的进程已随 bootout 结束，
+ *      manualStatus() 本身也排除了本进程与 launchd 托管链）；
+ *   3) rm -rf 配置目录 relayDir（账号/设备密钥/.dsh-config.json/.harness-cookie.json/
+ *      固化运行时 dsh-setup.mjs + clients 等全部残留）。
+ * 安全护栏：
+ *   - DSH_RELAY_SKIP_SERVICE=1（测试隔离开关，生产勿设）：跳过 1/2 的一切系统级操作，
+ *     只清理配置目录——避免测试真的去 launchctl / systemctl / kill 真实服务；
+ *   - 自启动文件只处理「属于当前 HOME 的 plist/unit」，误配/测试环境不碰同名真实服务；
+ *   - 配置目录删除前校验：不是 "/"、不是家目录、不是 dsh web profile 目录或其父级（防误删用户数据）。
+ */
+function uninstallRuntime(relayDir, protectedPath) {
+  const out = {
+    stoppedService: false, // 自启动服务原本在运行且已停止
+    removedPlist: false,   // 自启动文件（plist / systemd unit）已删除
+    killedPids: [],        // 额外结束的残留进程 pid 列表
+    removedDir: false,     // 配置目录 relayDir 已整目录清空
+    servicePlatform: platform() === "darwin" ? "launchd" : platform() === "linux" ? "systemd" : "none",
+  };
+  const skipService = process.env.DSH_RELAY_SKIP_SERVICE === "1";
+  if (!skipService) {
+    // a) 停服务 + 移除自启动文件
+    try {
+      if (platform() === "darwin") {
+        // 只处理「plist 位于当前 HOME」的服务：本插件/dsh-setup.mjs 安装的服务一定在此
+        const plistPath = launchAgentPath();
+        if (plistPath && existsSync(plistPath)) {
+          if (launchdStatus().running) {
+            const r = stopBridge(); // launchctl bootout → KeepAlive 一并失效
+            out.stoppedService = r.ok;
+          }
+          rmSync(plistPath, { force: true });
+          out.removedPlist = !existsSync(plistPath);
+        }
+      } else if (platform() === "linux") {
+        // systemd --user 用户态服务，与 dsh-setup.mjs 安装的 dsh-bridge 同名
+        const isActive = sh("systemctl --user is-active dsh-bridge");
+        if (isActive.ok && String(isActive.stdout).trim() === "active") {
+          sh("systemctl --user stop dsh-bridge");
+          const after = sh("systemctl --user is-active dsh-bridge");
+          out.stoppedService = !(after.ok && String(after.stdout).trim() === "active");
+        }
+        sh("systemctl --user disable dsh-bridge"); // 幂等；失败不致命
+        const unitPath = join(homedir(), ".config", "systemd", "user", "dsh-bridge.service");
+        if (existsSync(unitPath)) {
+          try { rmSync(unitPath, { force: true }); } catch { /* 非关键 */ }
+          sh("systemctl --user daemon-reload");
+          out.removedPlist = !existsSync(unitPath);
+        }
+      }
+    } catch { /* 服务清理失败不致命：目录照常清理，剩余残留可由用户手动处理 */ }
+    // b) 杀残留手动进程（launchd 托管的已随 bootout 结束；manualStatus 排除本进程）
+    try {
+      const manual = manualStatus();
+      const targets = [...manual.watcher, ...manual.bridge];
+      for (const pid of targets) {
+        try { process.kill(pid, "SIGTERM"); out.killedPids.push(pid); } catch { /* EPERM/ESRCH 忽略 */ }
+      }
+      if (targets.length) {
+        try { execSync("sleep 1", { timeout: 3000 }); } catch { /* 等待进程退出 */ }
+        for (const pid of targets) {
+          if (pidAlive(pid)) {
+            try { process.kill(pid, "SIGKILL"); } catch { /* 已退出 */ }
+          }
+        }
+      }
+    } catch { /* ignore */ }
+  }
+  // c) 清空配置目录（账号/密钥/会话 cookie/固化运行时等全部残留）
+  try {
+    const isRoot = dirname(relayDir) === relayDir;                     // "/" 或盘符根
+    const isHome = relayDir === homedir();
+    const hitsProfile = Boolean(protectedPath) && (
+      relayDir === protectedPath || relayDir.startsWith(protectedPath + sep)
+      || protectedPath.startsWith(relayDir + sep)
+    ); // 配置目录误指向 dsh web profile → 绝不整目录删除
+    if (relayDir && !isRoot && !isHome && !hitsProfile && existsSync(relayDir)) {
+      rmSync(relayDir, { recursive: true, force: true });
+      out.removedDir = !existsSync(relayDir);
+    }
+  } catch { /* 目录正被占用等：删除失败不致命（残留可由用户手动删除） */ }
+  return out;
+}
+
 // ---------- relay API 代理（直连，不走系统代理；undici 默认忽略代理环境变量） ----------
 
 async function relayFetch(relayDir, pathname, init) {
@@ -587,6 +704,12 @@ async function composeStatus(relayDir) {
   const cfg = loadConfig(relayDir);
   const launchd = launchdStatus();
   const manual = manualStatus();
+  // 注册/绑定失败提示(bridge 写 .bind-error.json;面板据此展示“已达上限/需解绑”引导)
+  let bindError = null;
+  try {
+    const f = join(relayDir, ".bind-error.json");
+    if (existsSync(f)) bindError = JSON.parse(readFileSync(f, "utf8"));
+  } catch { /* 无/损坏忽略 */ }
   // 远程地址（public-config 的 app_url，取不到用默认）
   const pub = await relayFetch(relayDir, "/api/public-config");
   const pubBody = pub.ok && pub.body && typeof pub.body === "object" ? pub.body : {};
@@ -610,6 +733,7 @@ async function composeStatus(relayDir) {
       launchd,
       manual,
       running: launchd.running || manual.bridge.length > 0,
+      bindError,
     },
     host: hostname(),
   };
@@ -713,7 +837,7 @@ async function proxyFeedback(relayDir, req, res, pathname) {
 // ---------- 自管理：版本 / 在线更新 / 彻底卸载（面板内“版本与更新”卡片） ----------
 
 /** 插件自身发布版本（与 dsh-remote 根包同步递增）。 */
-const PLUGIN_VERSION = "0.4.6";
+const PLUGIN_VERSION = "0.4.8";
 const UPDATE_LOG = ".dsh-update.log";
 const UPDATE_MARKER = ".dsh-update-running";
 
@@ -796,7 +920,7 @@ function tailOf(filePath, lines = 24) {
   } catch { return ""; }
 }
 
-/** 彻底卸载（兼容市场“拒绝改写用户补丁”的场景）：移除 include、依赖、bundle、本地目录与链接。 */
+/** 彻底卸载第 2 步 —— profile 插件清理（兼容市场“拒绝改写用户补丁”）：移除 include、依赖、bundle、本地目录与链接。 */
 function uninstallSelf(relayDir, profileDir, patchFile, pkgFile) {
   const out = { removedPatch: false, removedDep: false, removedDir: false, removedBundle: false };
   try {
@@ -875,8 +999,30 @@ function registerRoutes(ctx, relayDir) {
       method: "POST",
       path: "/dsh-remote/self/uninstall",
       handler: async (_req, res) => {
-        const r = uninstallSelf(relayDir, profileDir, join(profileDir, "cordis.patch.yml"), join(profileDir, "package.json"));
-        sendJson(res, 200, { ok: true, ...r, detail: "已移除插件引用与本地文件，重启 dsh web 后完全卸载生效" });
+        // 彻底卸载 = ① 运行时/bridge 清理（停自启动 → 杀残留 → 清空配置目录，顺序防 KeepAlive 复活）
+        //           + ② 插件 profile 清理（include 块/依赖/bundle/本地目录与链接，解锁市场卸载）
+        const rt = uninstallRuntime(relayDir, profileDir);
+        const prof = uninstallSelf(relayDir, profileDir, join(profileDir, "cordis.patch.yml"), join(profileDir, "package.json"));
+        // 卸载后本进程内（直到重启）自愈/代持调度一律停摆，不再重建配置目录或拉起 bridge
+        markUninstalled(relayDir);
+        const bits = [];
+        if (prof.removedPatch || prof.removedDep || prof.removedBundle || prof.removedDir) bits.push("插件引用与本地文件已移除");
+        if (rt.stoppedService) bits.push("bridge 自启动服务已停止");
+        if (rt.removedPlist) bits.push("自启动项已删除");
+        if (rt.killedPids.length) bits.push(`已结束 ${rt.killedPids.length} 个残留进程`);
+        if (rt.removedDir) bits.push("配置目录已清空（账号/密钥/固化运行时等）");
+        bits.push("请重启 dsh web 后完全卸载生效（本插件与远程控制将消失）；如需再次使用，在插件市场重新安装即可。");
+        sendJson(res, 200, {
+          ok: true,
+          ...prof, // removedPatch / removedDep / removedBundle / removedDir(profile 插件目录)
+          servicePlatform: rt.servicePlatform,
+          stoppedService: rt.stoppedService,
+          removedPlist: rt.removedPlist,
+          killedPids: rt.killedPids,
+          relayDirRemoved: rt.removedDir, // 配置目录 relayDir 已整目录清空
+          relayDir,
+          detail: bits.join("；"),
+        });
       },
     },
     {
@@ -1147,6 +1293,8 @@ function registerRoutes(ctx, relayDir) {
  */
 export function apply(ctx, config = {}) {
   const relayDir = config.relayDir || process.env.DSH_RELAY_DIR || DEFAULT_RELAY_DIR;
+  // 全新激活（dsh web 重启后插件重新加载，或卸载后再次安装）→ 解除上次的「已卸载」停摆标记
+  UNINSTALLED_DIRS.delete(relayDir);
   // 清理上次进程残留的安装/更新 marker（宿主被重启/强杀时子进程清理回调会丢失）
   sweepStaleMarkers(relayDir);
   ctx.effect(() => registerRoutes(ctx, relayDir), "dsh-remote-ui: /dsh-remote routes");

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

@@ -1,7 +1,7 @@
 {
   "name": "dsh-remote-ui",
   "version": "0.1.0",
-  "description": "Remote control for dsh web from a phone browser: an in-harness Settings panel (cloud/self-hosted mode tabs, account login, bridge start/stop, feedback) plus same-origin /dsh-remote relay routes; the desktop bridge and self-hosted relay-router shipped with this repo tunnel the local dsh web to a phone PWA with access-key auth, live device list and optional traffic quotas. · dsh web 远程控制插件：设置页「远程控制」栏目（settings.section 官方扩展点）+ 配置面板 + bridge 启停 + 反馈/邀请/满意度（双半插件：node 半提供 /dsh-remote 宿主 API，浏览器半提供 UI）。",
+  "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).",
   "type": "module",
   "main": "lib/index.js",
   "exports": {

package/packages/dsh-remote-ui/test/self-manage.test.mjs

@@ -175,6 +175,9 @@ test("uninstall 路由：移除 include 块 + package.json 依赖/bundle + 本
   await writeFile(path.join(relayDir, ".dsh-config.json"), "{}");
 
   try {
+    // 测试隔离开关：卸载路由跳过 launchctl / systemctl / 杀进程等系统级操作（本机真实 bridge 正由 launchd 运行，
+    // 不能被测试误停），只验证「插件 profile 清理 + 配置目录清空」逻辑。
+    process.env.DSH_RELAY_SKIP_SERVICE = "1";
     // 关键：以 tempHome 为 HOME 启动，profileDir 默认推导才会落在 temp profile 而非真实 ~/.dsh
     const routes = boot(tempHome, relayDir);
     const { host, base } = await serve(routes);
@@ -186,6 +189,15 @@ test("uninstall 路由：移除 include 块 + package.json 依赖/bundle + 本
       assert.equal(r.removedBundle, true, "应移除 dsh.profile.bundles 条目");
       assert.equal(r.removedDir, true, "应删除本地插件目录与 node_modules 链接");
 
+      // 运行时/bridge 清理（隔离模式下只清空配置目录，绝不触碰真实 launchd 服务）
+      assert.equal(r.relayDirRemoved, true, "配置目录 relayDir 应被整目录清空");
+      assert.equal(r.stoppedService, false, "DSH_RELAY_SKIP_SERVICE=1 → 不做真实服务操作");
+      assert.equal(r.removedPlist, false, "DSH_RELAY_SKIP_SERVICE=1 → 不删自启动 plist");
+      assert.deepEqual(r.killedPids, [], "DSH_RELAY_SKIP_SERVICE=1 → 不杀进程");
+      assert.equal(existsSync(relayDir), false, "relayDir 物理上应已不存在");
+      assert.match(String(r.detail), /配置目录已清空/, "detail 应说明配置目录已清空");
+      assert.match(String(r.detail), /请重启 dsh web/, "detail 应提示重启生效");
+
       const patch = await readFile(patchFile, "utf8");
       assert.ok(!patch.includes("dsh-remote-ui"), "patch 不应再引用 dsh-remote-ui");
       assert.ok(patch.includes("other-plugin"), "其他插件 include 不应被误伤");
@@ -198,6 +210,7 @@ test("uninstall 路由：移除 include 块 + package.json 依赖/bundle + 本
       host.close();
     }
   } finally {
+    delete process.env.DSH_RELAY_SKIP_SERVICE;
     await rm(tempHome, { recursive: true, force: true });
   }
 });

package/packages/dsh-remote-ui/test/uninstall-runtime.test.mjs

@@ -0,0 +1,317 @@
+// 插件 node 半「彻底卸载（运行时/bridge 清理）」回归：/dsh-remote/self/uninstall 的新增行为。
+// 背景：用户反馈卸载不干净——bridge 自启动服务（launchd com.dshremote.bridge / Linux dsh-bridge）
+//       仍在运行、自启动 plist/unit 仍在、配置目录 ~/.dsh-remote（账号/设备密钥/.dsh-config.json/
+//       .harness-cookie.json/固化运行时 dsh-setup.mjs + clients 等）也还在。
+// 卸载路由现在依次执行：profile 插件清理（uninstallSelf，原逻辑）+ 运行时清理（uninstallRuntime：
+// 停自启动服务 → 删自启动文件 → 杀残留进程 → rm -rf 配置目录），全部幂等、单项失败不致命。
+// 测试隔离（绝不触碰本机真实 launchd/systemd/进程）：
+//   - 大多数用例设 DSH_RELAY_SKIP_SERVICE=1 → 跳过一切系统级操作，只验证配置目录清理与 profile 清理；
+//   - 「自然跳过」用例把 PATH 指向假 launchctl/pgrep/ps，完全接管系统命令后走无开关路径。
+import assert from "node:assert/strict";
+import http from "node:http";
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { apply } from "../lib/index.js";
+
+const PLUGIN_BLOCK = `# >>> dsh-remote-ui (managed by dsh-remote plugin; do not edit)
+- type: plugin
+  name: dsh-remote-ui
+  apply: dsh-remote-ui
+# <<< dsh-remote-ui
+`;
+
+/** 加载插件（要求调用方已把 process.env.HOME 指向 tempHome；profile 推导才落在 temp 而非真实 ~/.dsh）。 */
+function boot(relayDir) {
+  const routes = new Map();
+  apply({
+    webServer: { register(route) { routes.set(route.path, route.handler); return () => {}; } },
+    effect(register) { return register(); },
+    logger: { info() {}, warn() {} }
+  }, { relayDir });
+  return routes;
+}
+
+/** 起一个指向 routes 的 http server，返回 base url。 */
+async function serve(routes) {
+  const host = http.createServer((req, res) => {
+    const url = new URL(req.url, "http://x");
+    const handler = routes.get(url.pathname);
+    (handler || ((_r, rs) => { rs.writeHead(404); rs.end(); }))(req, res);
+  });
+  await new Promise((resolve) => host.listen(0, "127.0.0.1", resolve));
+  return { host, base: `http://127.0.0.1:${host.address().port}` };
+}
+
+/** 在 tempHome 下造一份「真实安装痕迹」：profile（patch+package.json+插件目录）+ relayDir（配置/密钥/运行时）。 */
+async function plantInstallation(tempHome, opts = {}) {
+  const relayDir = opts.relayDir || path.join(tempHome, "relay");
+  const profile = path.join(tempHome, ".dsh", "profiles", "web");
+  await mkdir(profile, { recursive: true });
+  await writeFile(path.join(profile, "cordis.patch.yml"), `base: .\ninclude:\n${PLUGIN_BLOCK}  - other-plugin\n`);
+  await writeFile(path.join(profile, "package.json"), JSON.stringify({
+    dependencies: { "dsh-remote-ui": "github:mrRisega/dsh-remote#path:/packages/dsh-remote-ui", "other": "^1.0.0" },
+    dsh: { profile: { bundles: ["dsh-remote-ui", "other-bundle"] } },
+  }));
+  if (!opts.skipPluginDirs) {
+    await mkdir(path.join(profile, "dsh-remote-ui-plugin"), { recursive: true });
+    await mkdir(path.join(profile, "node_modules", "dsh-remote-ui"), { recursive: true });
+    await writeFile(path.join(profile, "dsh-remote-ui-plugin", "index.js"), "// stub");
+    await writeFile(path.join(profile, "node_modules", "dsh-remote-ui", "index.js"), "// stub");
+  }
+  if (!opts.skipRelay) {
+    // 模拟固化运行时 + 账号/密钥/会话 cookie/安装标记等全部残留
+    await mkdir(path.join(relayDir, "clients", "dsh-remote"), { recursive: true });
+    await writeFile(path.join(relayDir, ".dsh-config.json"), JSON.stringify({
+      phone: "13800000000", password: "pw", device_id: "dev", device_private_key: "pk", local_key: "lk",
+    }));
+    await writeFile(path.join(relayDir, "dsh-setup.mjs"), "// runtime stub");
+    await writeFile(path.join(relayDir, "clients", "dsh-remote", "dsh-bridge.mjs"), "// bridge stub");
+    await writeFile(path.join(relayDir, ".harness-cookie.json"), JSON.stringify({ authority: "127.0.0.1:3080", cookie: "dsh-auth-x=1" }));
+    await writeFile(path.join(relayDir, ".dsh-setup-installing"), JSON.stringify({ pid: 999999, at: Date.now() }));
+    await writeFile(path.join(relayDir, ".dsh-update-running"), JSON.stringify({ pid: 999999, at: Date.now() }));
+    await writeFile(path.join(relayDir, "unrelated-marker.txt"), "keep-me");
+  }
+  return { relayDir, profile };
+}
+
+test("彻底卸载：配置目录整目录清空（含账号/密钥/固化运行时），不误伤 profile 其它条目与家目录其它数据", async () => {
+  const tempHome = await mkdtemp(path.join(os.tmpdir(), "dsh-ui-rt-"));
+  const prevHome = process.env.HOME;
+  process.env.HOME = tempHome;
+  process.env.DSH_RELAY_SKIP_SERVICE = "1"; // 测试隔离：跳过 launchctl/systemctl/杀进程
+  try {
+    const { relayDir, profile } = await plantInstallation(tempHome);
+    // 家目录里放一份「用户自己的数据」：卸载绝不能误删
+    await writeFile(path.join(tempHome, "my-notes.txt"), "user data");
+    const routes = boot(relayDir);
+    const { host, base } = await serve(routes);
+    try {
+      const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      assert.equal(r.ok, true);
+      // profile 清理（原 uninstallSelf 行为不变）
+      assert.equal(r.removedPatch, true);
+      assert.equal(r.removedDep, true);
+      assert.equal(r.removedBundle, true);
+      assert.equal(r.removedDir, true, "profile 插件目录与 node_modules 链接应删除");
+      // 运行时清理标志位
+      assert.equal(r.relayDirRemoved, true, "relayDir 应被整目录清空");
+      assert.equal(r.servicePlatform, "launchd", "macOS 下 servicePlatform=launchd");
+      assert.equal(r.stoppedService, false, "DSH_RELAY_SKIP_SERVICE=1 → 不触碰真实 launchd 服务");
+      assert.equal(r.removedPlist, false);
+      assert.deepEqual(r.killedPids, []);
+      // 物理断言：relayDir 与其中全部残留都消失
+      assert.equal(existsSync(relayDir), false, "relayDir 目录应整体不存在");
+      assert.equal(existsSync(path.join(relayDir, ".dsh-config.json")), false);
+      assert.equal(existsSync(path.join(relayDir, "dsh-setup.mjs")), false);
+      assert.equal(existsSync(path.join(relayDir, "clients")), false);
+      // 不误伤：profile 的其它 include/依赖仍在；家目录其它文件仍在
+      const patch = await readFile(path.join(profile, "cordis.patch.yml"), "utf8");
+      assert.ok(!patch.includes("dsh-remote-ui") && patch.includes("other-plugin"), "patch 只移除插件条目");
+      const pkg = JSON.parse(await readFile(path.join(profile, "package.json"), "utf8"));
+      assert.equal(pkg.dependencies["other"], "^1.0.0");
+      assert.deepEqual(pkg.dsh.profile.bundles, ["other-bundle"]);
+      assert.equal(existsSync(path.join(tempHome, "my-notes.txt")), true, "家目录其它用户数据不得被删");
+      assert.equal(existsSync(profile), true, "dsh web profile 目录整体不得被删");
+      // 人类可读 detail
+      assert.match(String(r.detail), /插件引用与本地文件已移除/);
+      assert.match(String(r.detail), /配置目录已清空/);
+      assert.match(String(r.detail), /请重启 dsh web/);
+    } finally {
+      host.close();
+    }
+  } finally {
+    delete process.env.DSH_RELAY_SKIP_SERVICE;
+    process.env.HOME = prevHome;
+    await rm(tempHome, { recursive: true, force: true });
+  }
+});
+
+test("彻底卸载边界：只装了插件、从未跑过 bridge → relayDir 不存在仍返回成功且不虚报「已清空」", async () => {
+  const tempHome = await mkdtemp(path.join(os.tmpdir(), "dsh-ui-rt-nodir-"));
+  const prevHome = process.env.HOME;
+  process.env.HOME = tempHome;
+  process.env.DSH_RELAY_SKIP_SERVICE = "1";
+  try {
+    // profile 有插件引用，但 relayDir（~/.dsh-remote）从未被创建
+    const relayDir = path.join(tempHome, "relay");
+    await plantInstallation(tempHome, { skipRelay: true });
+    assert.equal(existsSync(relayDir), false);
+    const routes = boot(relayDir);
+    const { host, base } = await serve(routes);
+    try {
+      const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      assert.equal(r.ok, true);
+      assert.equal(r.removedPatch, true, "profile 里的插件引用应照常清理");
+      assert.equal(r.relayDirRemoved, false, "目录本就不存在 → 不声称已清空");
+      assert.equal(r.stoppedService, false);
+      assert.equal(r.removedPlist, false);
+      assert.deepEqual(r.killedPids, []);
+      const detail = String(r.detail);
+      assert.ok(!detail.includes("配置目录已清空"), "目录不存在时不应谎报已清空，实际: " + detail);
+      assert.match(detail, /请重启 dsh web/);
+    } finally {
+      host.close();
+    }
+  } finally {
+    delete process.env.DSH_RELAY_SKIP_SERVICE;
+    process.env.HOME = prevHome;
+    await rm(tempHome, { recursive: true, force: true });
+  }
+});
+
+test("彻底卸载边界：什么都没有安装 → 全链路幂等返回 ok，不抛错不崩溃", async () => {
+  const tempHome = await mkdtemp(path.join(os.tmpdir(), "dsh-ui-rt-empty-"));
+  const prevHome = process.env.HOME;
+  process.env.HOME = tempHome;
+  process.env.DSH_RELAY_SKIP_SERVICE = "1";
+  try {
+    const relayDir = path.join(tempHome, "relay"); // 不存在
+    const routes = boot(relayDir);
+    const { host, base } = await serve(routes);
+    try {
+      const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      assert.equal(r.ok, true);
+      assert.equal(r.relayDirRemoved, false);
+      assert.equal(r.removedPatch, false);
+      assert.equal(r.removedDep, false);
+      assert.equal(r.removedBundle, false);
+      assert.deepEqual(r.killedPids, []);
+      assert.match(String(r.detail), /请重启 dsh web/);
+    } finally {
+      host.close();
+    }
+  } finally {
+    delete process.env.DSH_RELAY_SKIP_SERVICE;
+    process.env.HOME = prevHome;
+    await rm(tempHome, { recursive: true, force: true });
+  }
+});
+
+test("DSH_RELAY_SKIP_SERVICE 开关：置位时即便存在自启动 plist 也不执行系统级清理，仅清空配置目录", async () => {
+  const tempHome = await mkdtemp(path.join(os.tmpdir(), "dsh-ui-rt-gate-"));
+  const prevHome = process.env.HOME;
+  process.env.HOME = tempHome;
+  process.env.DSH_RELAY_SKIP_SERVICE = "1";
+  try {
+    const { relayDir } = await plantInstallation(tempHome);
+    // 在「当前 HOME 的 LaunchAgents」放一个真实存在的 plist：开关必须挡下删除动作
+    const fakePlist = path.join(tempHome, "Library", "LaunchAgents", "com.dshremote.bridge.plist");
+    await mkdir(path.dirname(fakePlist), { recursive: true });
+    await writeFile(fakePlist, "<?xml version=\"1.0\"?><plist version=\"1.0\"><dict/></plist>");
+    const routes = boot(relayDir);
+    const { host, base } = await serve(routes);
+    try {
+      const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      assert.equal(r.ok, true);
+      assert.equal(r.removedPlist, false, "开关置位 → plist 不得被删");
+      assert.equal(existsSync(fakePlist), true, "plist 应原样保留（开关只放行配置目录清理）");
+      assert.equal(r.relayDirRemoved, true, "配置目录清理不受开关影响");
+      assert.equal(existsSync(relayDir), false);
+    } finally {
+      host.close();
+    }
+  } finally {
+    delete process.env.DSH_RELAY_SKIP_SERVICE;
+    process.env.HOME = prevHome;
+    await rm(tempHome, { recursive: true, force: true });
+  }
+});
+
+test("自然跳过（无开关）：HOME 有 plist 但服务未运行 → 删除 plist 但不发 launchctl bootout（PATH 假命令接管）", async () => {
+  const tempHome = await mkdtemp(path.join(os.tmpdir(), "dsh-ui-rt-natural-"));
+  const prevHome = process.env.HOME;
+  const prevPath = process.env.PATH;
+  const prevLog = process.env.DSH_TEST_LAUNCH_LOG;
+  process.env.HOME = tempHome;
+  delete process.env.DSH_RELAY_SKIP_SERVICE; // 明确走无开关的真实分支
+  const launchLog = path.join(tempHome, "launchctl.log");
+  try {
+    // 假系统命令：launchctl 只记录参数、绝不报 running；pgrep/ps 一律空
+    const fakeBin = path.join(tempHome, "bin");
+    await mkdir(fakeBin, { recursive: true });
+    const fakeLaunchctl = `#!/bin/sh
+printf '%s\n' "$*" >> "$DSH_TEST_LAUNCH_LOG"
+exit 0
+`;
+    const fakeNoMatch = "#!/bin/sh\nexit 1\n";
+    writeFileSync(path.join(fakeBin, "launchctl"), fakeLaunchctl); chmodSync(path.join(fakeBin, "launchctl"), 0o755);
+    writeFileSync(path.join(fakeBin, "pgrep"), fakeNoMatch); chmodSync(path.join(fakeBin, "pgrep"), 0o755);
+    writeFileSync(path.join(fakeBin, "ps"), fakeNoMatch); chmodSync(path.join(fakeBin, "ps"), 0o755);
+    process.env.PATH = `${fakeBin}:${prevPath}`;
+    process.env.DSH_TEST_LAUNCH_LOG = launchLog;
+
+    const { relayDir } = await plantInstallation(tempHome);
+    // 当前 HOME 的 LaunchAgents 里有 plist（服务此前装过，但现在未运行）
+    const plist = path.join(tempHome, "Library", "LaunchAgents", "com.dshremote.bridge.plist");
+    await mkdir(path.dirname(plist), { recursive: true });
+    await writeFile(plist, "<?xml version=\"1.0\"?><plist version=\"1.0\"><dict/></plist>");
+
+    const routes = boot(relayDir);
+    const { host, base } = await serve(routes);
+    try {
+      const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      assert.equal(r.ok, true);
+      assert.equal(r.removedPlist, true, "plist 存在于当前 HOME → 应被删除");
+      assert.equal(existsSync(plist), false);
+      assert.equal(r.stoppedService, false, "服务未运行 → 无需 bootout，不虚报已停止");
+      assert.deepEqual(r.killedPids, [], "无残留进程可杀");
+      assert.equal(r.relayDirRemoved, true);
+      assert.equal(existsSync(relayDir), false);
+      // 关键：全程不得发出 bootout（避免任何真实/假服务被停）
+      const log = readFileSync(launchLog, "utf8");
+      assert.ok(!log.includes("bootout"), "未运行的服务不应触发 bootout，实际调用: " + log);
+    } finally {
+      host.close();
+    }
+  } finally {
+    if (prevLog === undefined) delete process.env.DSH_TEST_LAUNCH_LOG; else process.env.DSH_TEST_LAUNCH_LOG = prevLog;
+    process.env.PATH = prevPath;
+    process.env.HOME = prevHome;
+    await rm(tempHome, { recursive: true, force: true });
+  }
+});
+
+test("保护参数：relayDir 误配置成 dsh web profile 目录 → 绝不整目录删除（防误删 dsh 本体）", async () => {
+  const tempHome = await mkdtemp(path.join(os.tmpdir(), "dsh-ui-rt-protect-"));
+  const prevHome = process.env.HOME;
+  process.env.HOME = tempHome;
+  process.env.DSH_RELAY_SKIP_SERVICE = "1";
+  try {
+    // relayDir 与 profileDir 相同（异常配置）：卸载只清插件引用/文件，绝不能 rm 整个 profile
+    const profile = path.join(tempHome, ".dsh", "profiles", "web");
+    const { relayDir } = await plantInstallation(tempHome, { relayDir: profile, skipRelay: true });
+    assert.equal(relayDir, profile);
+    const routes = boot(relayDir);
+    const { host, base } = await serve(routes);
+    try {
+      const r = await (await fetch(`${base}/dsh-remote/self/uninstall`, { method: "POST" })).json();
+      assert.equal(r.ok, true);
+      assert.equal(r.relayDirRemoved, false, "profile 目录受保护 → 不得整目录删除");
+      assert.equal(existsSync(profile), true, "dsh web profile 必须存活");
+      assert.equal(existsSync(path.join(profile, "package.json")), true);
+      assert.equal(existsSync(path.join(profile, "dsh-remote-ui-plugin")), false, "插件子目录应被 uninstallSelf 单独移除");
+      assert.equal(existsSync(path.join(profile, "node_modules", "dsh-remote-ui")), false);
+    } finally {
+      host.close();
+    }
+  } finally {
+    delete process.env.DSH_RELAY_SKIP_SERVICE;
+    process.env.HOME = prevHome;
+    await rm(tempHome, { recursive: true, force: true });
+  }
+});
+
+test("源码约束：浏览器半彻底卸载文案与行为说明 bridge 服务与本地配置一并移除/清空", () => {
+  const source = readFileSync(new URL("../lib/client.js", import.meta.url), "utf8");
+  // 二次确认文案：说明会停 bridge 自启动、清配置目录（不再有旧的「bridge 与数据目录保留」误导）
+  assert.match(source, /停止并移除 bridge 自启动服务/);
+  assert.match(source, /清空本地配置目录/);
+  assert.ok(!source.includes("bridge 与数据目录保留"), "旧文案已移除：卸载不再保留 bridge 与数据目录");
+  // 成功提示：优先展示服务端 detail，兜底文案同样声明 bridge/本地配置已移除
+  assert.match(source, /b\.detail/);
+  assert.match(source, /bridge 自启动服务与本地配置目录/);
+  assert.match(source, /请重启 dsh web/);
+});