@mrrisega/dsh-remote 0.6.6 → 0.6.7-beta.2

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

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.6.6",
+  "version": "0.6.7-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",

package/packages/dsh-remote-web/test/community-qr-ui.test.mjs

@@ -1,4 +1,4 @@
-// 交流群二维码（运营配置）在插件侧的两处展示回归：
+// 交流群二维码（后台配置）在插件侧的两处展示回归：
 //   ① 设置面板：「💬 加入交流群」按钮 → 点击弹出二维码大图（未配置后台码 → 按钮不存在）；
 //   ② 用户反馈页：底部直接展示企微交流群二维码 + 文案。
 // 数据来源：node 半 GET /dsh-remote/community（读公开配置 community.qrcode 并拼绝对地址）。

package/packages/dsh-remote-web/test/connect-loop.test.mjs

@@ -1,6 +1,6 @@
 // 「登录后自动闭环」回归（node 半，0.6.4）。
 //
-// 现场（2026-09 生产数据，id 42~52 共 11 个真实注册用户）：只有 3 人最终绑定了设备，其余 8 人的
+// 现场观察：新注册用户里只有少数最终绑定了设备，其余的
 // 电脑端 bridge 从未连上过中继；多人反复点「生成访问链接」（auth.key_create 10~23 次）而
 // device.bind 始终为 0。典型路径：注册 → 手机端 /api/devices 拿到空列表 → 反复轮询 → 放弃。
 //

package/packages/dsh-remote-web/test/connect-ui.test.mjs

@@ -1,8 +1,8 @@
 // 「登录后自动闭环」UI 回归（浏览器半，0.6.4；真实 useEffect + 可控假定时器 + 可控 document.hidden）。
 //
-// 现场（2026-09 生产数据）：注册后手机端一直是空设备列表，用户在设置面板反复点「生成访问链接」
-// （auth.key_create 10~23 次）却始终没有 device.bind——他们看不到「到底卡在哪一步」，也不知道
-// 要不要刷新页面。本用例锁死面板侧的自动闭环：
+// 现场：注册后手机端一直是空设备列表，用户在设置面板反复点「生成访问链接」
+// 却始终没有 device.bind——他们看不到「到底卡在哪一步」，也不知道要不要刷新页面。
+// 本用例锁死面板侧的自动闭环：
 //   ① 登录后立刻进入启动/连接流程（2.5s 短轮询自动推进，不需要点任何按钮）；
 //   ② 阶段推进到 online → UI 自动变成「已连接 ✅ 现在可以用手机扫码访问」，并自动重取二维码与
 //      已授权设备列表（全程不刷新页面）；

package/packages/dsh-remote-web/test/installer-cli.test.mjs

@@ -0,0 +1,82 @@
+/**
+ * 安装器命令行分派契约测试（行为级，真起进程）。
+ *
+ * 背景（2026-09-17 实测发现）：`dsh-remote --help` 过去会**直接开始安装** ——
+ * 分派逻辑是「首个参数以 `-` 开头就当成 setup 的参数」，而 `--help` 不在任何分支里，
+ * 于是落到默认的 setup 路径：往 ~/.dsh-remote 同步运行时脚本、装插件、登记自启动。
+ * 用户想先看一眼用法，结果被装了一整套东西。
+ *
+ * 本用例锁死两条：
+ *   ① `--help` / `-h` / `help` → 打印用法、退出码 0、**不碰磁盘**；
+ *   ② 参数拼错（不认识的 flag）→ 明确报错、退出码 1、**也不碰磁盘**。
+ *
+ * ⚠️ 隔离：所有用例都伪造 HOME + DSH_PROFILE_DIR，并设 DSH_RELAY_SKIP_SERVICE=1，
+ * 否则会污染真实的自启动服务与 ~/.dsh-remote（见 setup-output.test.mjs 的事故复盘）。
+ */
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SETUP = path.join(HERE, "..", "..", "..", "dsh-setup.mjs");
+
+/** 在隔离 HOME 下运行安装器，返回 { code, stdout, stderr, touched }。 */
+function runInstaller(args) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "dsh-cli-"));
+  return new Promise((resolve) => {
+    execFile(
+      process.execPath,
+      [SETUP, ...args],
+      {
+        env: {
+          ...process.env,
+          HOME: home,
+          DSH_RELAY_SKIP_SERVICE: "1",
+          DSH_PROFILE_DIR: path.join(home, "prof"),
+          DSH_RELAY_DIR: path.join(home, ".dsh-remote")
+        },
+        timeout: 30_000
+      },
+      (err, stdout, stderr) => {
+        const touched = fs.existsSync(path.join(home, ".dsh-remote"));
+        fs.rmSync(home, { recursive: true, force: true });
+        resolve({ code: err ? err.code ?? 1 : 0, stdout, stderr, touched });
+      }
+    );
+  });
+}
+
+test("--help / -h / help：打印用法、退出码 0、且不落盘", async () => {
+  for (const flag of ["--help", "-h", "help"]) {
+    const r = await runInstaller([flag]);
+    assert.equal(r.code, 0, `${flag} 应以 0 退出`);
+    assert.match(r.stdout, /用法:/, `${flag} 应打印用法`);
+    assert.match(r.stdout, /dsh-remote status/, `${flag} 的用法应列出子命令`);
+    assert.equal(r.touched, false, `${flag} 不得在用户主目录创建任何东西`);
+  }
+});
+
+test("参数拼错：明确报错、退出码 1、也不落盘", async () => {
+  for (const flag of ["--bogus", "--dry-run", "--hepl"]) {
+    const r = await runInstaller([flag]);
+    assert.equal(r.code, 1, `${flag} 应以 1 退出`);
+    assert.match(r.stderr, /未知参数/, `${flag} 应明确说是未知参数`);
+    assert.match(r.stderr, /--help/, `${flag} 的报错应告诉用户怎么看用法`);
+    assert.equal(r.touched, false, `${flag} 不得开始安装`);
+  }
+});
+
+test("源码级：用法文本只有一处实现（避免提前退出与末尾分派两处漂移）", () => {
+  const src = fs.readFileSync(SETUP, "utf8");
+  const hits = src.match(/dsh-remote — 手机远程控制 dsh web/g) || [];
+  assert.equal(hits.length, 1, "用法文案应只出现一次（共用 printHelp()）");
+  assert.match(src, /function printHelp\(\)/, "应有 printHelp()");
+  // 关键：提前退出必须挡在 ensureRuntimeCopy() 之前
+  const iHelp = src.indexOf("printHelp();\n    process.exit(0);");
+  const iSync = src.indexOf("try { ensureRuntimeCopy(); }");
+  assert.ok(iHelp > -1 && iSync > -1 && iHelp < iSync, "--help 的提前退出必须在运行时同步之前");
+});

package/packages/dsh-remote-web/test/plugin-link.test.mjs

@@ -0,0 +1,400 @@
+/**
+ * 插件挂载（node_modules/<id> 链接）回归 —— 0.6.7-beta.2 新增。
+ *
+ * 背景（Windows 用户实测，2026-09-18）：0.6.7-beta.1 的 `ensurePluginLinked` 用
+ * `fs.symlinkSync(target, path, "dir")` 建链接，并把 junction / 整目录拷贝两级兜底写在它的 `catch` 里。
+ * 在 **非特权进程 + 开发者模式关闭**（= 普通用户默认状态）下，`'dir'` 在 Windows 上
+ * **既不抛错也产不出可用链接**（实测：用户目录下留一个空目录，%TEMP% 下什么都不留；
+ * 同一位置两次运行一次报成功一次抛 UNKNOWN）。于是：
+ *   · 报成功 → catch 不进入 → 两级兜底永不执行 → 留下空壳/什么都没有；
+ *   · 报错   → catch 进入 → 但上一步已留空目录 → junction 撞 EEXIST → 只剩 cpSync 一支。
+ * 而调用方把返回值丢掉、patch 照写、还打印「✅ 插件已就绪」，最终
+ * dsh web 按裸包名解析到空目录 → `plugin tree failed to load` → **整个 dsh web 起不来**。
+ *
+ * ⚠️ 本文件存在的意义就是"上一版为什么漏测"：老用例只断言"函数没抛错 / 返回 true"，
+ * 而这里的断言对象是**通过 node_modules/<id> 这条路径到底能不能读到东西**，
+ * 并且用注入式 fs 代理**复现**了 Windows 那种"不抛错但落盘是空壳"的形态。
+ */
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const SETUP = path.join(HERE, "..", "..", "..", "dsh-setup.mjs");
+const PLUGIN_SRC = path.join(HERE, "..");
+const PLUGIN_ID = "dsh-remote-web";
+const SETUP_SRC = fs.readFileSync(SETUP, "utf8");
+
+// ─────────────── 源码内取函数（安装器是 CLI 脚本，import 会直接执行 main） ───────────────
+
+/** 取出 dsh-setup.mjs 里某个函数的源码文本。 */
+function fnSrc(name, nextMarker) {
+  const start = SETUP_SRC.indexOf(`function ${name}(`);
+  const end = SETUP_SRC.indexOf(nextMarker, start);
+  assert.ok(start > -1 && end > start, `应能从安装器源码里取出 ${name}`);
+  return SETUP_SRC.slice(start, end);
+}
+
+/** 用真实 fs/path 组装出被测函数（纯函数，可安全求值）。 */
+function loadLinkFns() {
+  const src = fnSrc("pluginLinkUsable", "/**\n * 把插件挂到")
+    + fnSrc("ensurePluginLinked", "/**\n * 独立验收：复刻 dsh 客户端模块系统的真实动作");
+  return new Function("fs", "path", "PLUGIN_ID", "PLUGIN_LEGACY_IDS",
+    `${src}; return { pluginLinkUsable, ensurePluginLinked };`)(fs, path, PLUGIN_ID, ["dsh-remote-ui"]);
+}
+
+/** 造一份"像真的"插件目录（package.json + lib/index.js 已是可用性判据的最低要求）。 */
+function makePluginDir(root, { name = PLUGIN_ID, withEntry = true } = {}) {
+  fs.mkdirSync(path.join(root, "lib"), { recursive: true });
+  fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name, version: "0.0.0-test" }));
+  if (withEntry) fs.writeFileSync(path.join(root, "lib", "index.js"), "export const x = 1;\n");
+  return root;
+}
+
+function tmpDir(prefix = "dsh-link-") {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+// ─────────────── ① 可用性判据必须否定所有畸形形态 ───────────────
+
+test("pluginLinkUsable：空目录/畸形链接一律判为不可用（不能只看'没抛错'）", () => {
+  const { pluginLinkUsable } = loadLinkFns();
+  const root = tmpDir();
+  try {
+    const local = makePluginDir(path.join(root, "local"));
+    const nm = path.join(root, "node_modules", PLUGIN_ID);
+    fs.mkdirSync(path.dirname(nm), { recursive: true });
+
+    assert.equal(pluginLinkUsable(nm, local), false, "不存在 → 不可用");
+
+    // 这就是本 bug 的落盘形态：一个同名空目录
+    fs.mkdirSync(nm, { recursive: true });
+    assert.equal(pluginLinkUsable(nm, local), false, "★空目录必须判为不可用（老实现正是在这里当作成功）");
+
+    // 有 package.json 但 name 不对（旧的别名包残留 / 别的包）
+    fs.writeFileSync(path.join(nm, "package.json"), JSON.stringify({ name: "dsh-remote-ui" }));
+    fs.mkdirSync(path.join(nm, "lib"), { recursive: true });
+    fs.writeFileSync(path.join(nm, "lib", "index.js"), "x");
+    assert.equal(pluginLinkUsable(nm, local), false, "name 不匹配 → 不可用（面板注入靠裸包名）");
+
+    // name 对了但没有节点半入口
+    fs.writeFileSync(path.join(nm, "package.json"), JSON.stringify({ name: PLUGIN_ID }));
+    fs.rmSync(path.join(nm, "lib", "index.js"));
+    assert.equal(pluginLinkUsable(nm, local), false, "缺 lib/index.js → 不可用");
+
+    // 内容完整 + realpath 指回本地目录 → 可用
+    fs.writeFileSync(path.join(nm, "lib", "index.js"), fs.readFileSync(path.join(local, "lib", "index.js")));
+    fs.rmSync(nm, { recursive: true, force: true });
+    // 正向对照必须按平台取链接类型：Windows 非特权进程下 'dir' 本来就建不出来（正是本 bug），
+    // 拿它当"正确答案"会让用例在真 Windows 上自己失败。
+    if (process.platform === "win32") fs.symlinkSync(local, nm, "junction");
+    else fs.symlinkSync(local, nm, "dir");
+    assert.equal(pluginLinkUsable(nm, local), true, "真链接 → 可用");
+
+    // 整目录拷贝（内容一致）→ 也算可用
+    fs.rmSync(nm, { recursive: true, force: true });
+    fs.cpSync(local, nm, { recursive: true });
+    assert.equal(pluginLinkUsable(nm, local), true, "整目录拷贝（内容一致）→ 可用");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ─────────────── ② 注入 Windows 的失败形态：不抛错但落盘是空壳 ───────────────
+
+/** 造一个 fs 代理：可按需让某个策略"静默失败"（不抛错、也不产出任何东西）。 */
+function fsProxy({ silentFail = [], emptyDirInstead = [] } = {}) {
+  return {
+    ...fs,
+    symlinkSync(target, p, type) {
+      if (emptyDirInstead.includes(type)) { fs.mkdirSync(p, { recursive: true }); return; } // ← 本 bug 的落盘形态
+      if (silentFail.includes(type)) return;                                               // ← 本 bug 的"报成功"
+      return fs.symlinkSync(target, p, type);
+    },
+    cpSync(...args) {
+      if (silentFail.includes("copy")) return;
+      return fs.cpSync(...args);
+    },
+  };
+}
+
+function loadLinkFnsWithFs(fakeFs) {
+  const src = fnSrc("pluginLinkUsable", "/**\n * 把插件挂到")
+    + fnSrc("ensurePluginLinked", "/**\n * 独立验收：复刻 dsh 客户端模块系统的真实动作");
+  return new Function("fs", "path", "PLUGIN_ID", "PLUGIN_LEGACY_IDS",
+    `${src}; return { pluginLinkUsable, ensurePluginLinked };`)(fakeFs, path, PLUGIN_ID, ["dsh-remote-ui"]);
+}
+
+test("ensurePluginLinked：'不抛错但什么都没建' 时，兜底链必须继续生效（本 bug 的核心）", () => {
+  const root = tmpDir();
+  try {
+    const local = makePluginDir(path.join(root, "local"));
+    const profile = path.join(root, "profile");
+    fs.mkdirSync(profile, { recursive: true });
+    // 模拟 Windows：junction 报告成功但落盘什么都没有（老实现据此当作成功、直接 return）
+    const { ensurePluginLinked } = loadLinkFnsWithFs(fsProxy({ silentFail: ["junction"] }));
+    const changed = ensurePluginLinked(profile, local);
+    assert.equal(changed, true, "应当重建并报告发生了变更");
+    const nm = path.join(profile, "node_modules", PLUGIN_ID);
+    assert.ok(fs.existsSync(path.join(nm, "package.json")), "★兜底必须真的把内容落盘（老实现在这里留下空壳）");
+    assert.ok(fs.existsSync(path.join(nm, "lib", "index.js")), "★节点半入口必须可读");
+    assert.ok(fs.readdirSync(nm).length > 0, "node_modules/<id> 是空目录 = 本 bug 复现");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("ensurePluginLinked：上一支留下空目录残留时，下一支不得被 EEXIST 顶掉", () => {
+  const root = tmpDir();
+  try {
+    const local = makePluginDir(path.join(root, "local"));
+    const profile = path.join(root, "profile");
+    fs.mkdirSync(profile, { recursive: true });
+    const { ensurePluginLinked } = loadLinkFnsWithFs(fsProxy({ emptyDirInstead: ["junction"] }));
+    ensurePluginLinked(profile, local);
+    const nm = path.join(profile, "node_modules", PLUGIN_ID);
+    assert.ok(fs.existsSync(path.join(nm, "lib", "index.js")),
+      "★先留空目录再走兜底也必须成功（老实现这里撞 EEXIST，三级兜底退化成一级）");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("ensurePluginLinked：所有策略都失败时必须抛错，绝不返回成功", () => {
+  const root = tmpDir();
+  try {
+    const local = makePluginDir(path.join(root, "local"));
+    const profile = path.join(root, "profile");
+    fs.mkdirSync(profile, { recursive: true });
+    const { ensurePluginLinked } = loadLinkFnsWithFs(fsProxy({ silentFail: ["junction", "dir", "copy"] }));
+    assert.throws(() => ensurePluginLinked(profile, local), /插件挂载失败/,
+      "全失败必须抛错 —— 否则调用方会写出一个起不来的 profile");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("ensurePluginLinked：已经挂好时幂等返回 false（不重复重建）", () => {
+  const root = tmpDir();
+  try {
+    const local = makePluginDir(path.join(root, "local"));
+    const profile = path.join(root, "profile");
+    fs.mkdirSync(profile, { recursive: true });
+    const { ensurePluginLinked } = loadLinkFns();
+    assert.equal(ensurePluginLinked(profile, local), true, "首次应重建");
+    assert.equal(ensurePluginLinked(profile, local), false, "已就绪应幂等返回 false");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ─────────────── ③ 真起进程：装完必须真的能被裸包名解析到 ───────────────
+
+/** 准备一个最小可用 profile（package.json + 空的 cordis.patch.yml）。 */
+function makeProfile(root) {
+  const profile = path.join(root, "prof");
+  fs.mkdirSync(profile, { recursive: true });
+  fs.writeFileSync(path.join(profile, "package.json"), JSON.stringify({ name: "dsh-profile-web", version: "0.0.0" }, null, 2));
+  fs.writeFileSync(path.join(profile, "cordis.patch.yml"), "[]\n");
+  return profile;
+}
+
+/** 在隔离 HOME 下跑安装器命令。 */
+function runInstaller(args, env = {}) {
+  const home = env.HOME || fs.mkdtempSync(path.join(os.tmpdir(), "dsh-link-home-"));
+  return new Promise((resolve) => {
+    execFile(process.execPath, [SETUP, ...args], {
+      env: { ...process.env, HOME: home, DSH_RELAY_SKIP_SERVICE: "1", DSH_RELAY_DIR: path.join(home, ".dsh-remote"), ...env },
+      timeout: 60_000,
+    }, (err, stdout, stderr) => resolve({ code: err ? (err.code ?? 1) : 0, stdout, stderr }));
+  });
+}
+
+/** 复刻 dsh 的真实解析动作（浏览器半注入设置面板靠它）。 */
+function resolveFromProfile(profile, spec) {
+  const req = createRequire(path.join(profile, "__probe.cjs"));
+  return req.resolve(spec);
+}
+
+test("端到端：安装器装完插件后，node_modules/<id> 必须真的可读、可解析（不能只看退出码）", async () => {
+  const root = tmpDir();
+  try {
+    const profile = makeProfile(root);
+    const r = await runInstaller(["plugin"], { DSH_PROFILE_DIR: profile });
+    assert.equal(r.code, 0, `安装应成功：${r.stdout}\n${r.stderr}`);
+
+    const nm = path.join(profile, "node_modules", PLUGIN_ID);
+    // ① 落盘可读 —— Windows 非特权下老代码在这里就挂了
+    const pkg = JSON.parse(fs.readFileSync(path.join(nm, "package.json"), "utf8"));
+    assert.equal(pkg.name, PLUGIN_ID);
+    assert.ok(fs.existsSync(path.join(nm, "lib", "index.js")), "节点半入口必须存在");
+    assert.ok(fs.readdirSync(nm).length > 0, "★空目录 = 本 bug 复现");
+
+    // ② 复刻 dsh 的解析动作
+    assert.ok(resolveFromProfile(profile, `${PLUGIN_ID}/package.json`).endsWith("package.json"));
+    assert.ok(resolveFromProfile(profile, PLUGIN_ID), "裸包名必须能解析到入口");
+    assert.equal(pkg.dsh.client.platform, "web", "浏览器半声明必须在（面板注入的前提）");
+
+    // ③ 激活行必须写进 patch
+    const patch = fs.readFileSync(path.join(profile, "cordis.patch.yml"), "utf8");
+    assert.match(patch, /dsh-remote-web/, "patch 里应有插件激活行");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("端到端：node_modules/<id> 已是空壳时，重新安装必须自愈", async () => {
+  const root = tmpDir();
+  try {
+    const profile = makeProfile(root);
+    // 复现中招现场：同名空目录
+    fs.mkdirSync(path.join(profile, "node_modules", PLUGIN_ID), { recursive: true });
+    const r = await runInstaller(["plugin"], { DSH_PROFILE_DIR: profile });
+    assert.equal(r.code, 0, `重装应自愈：${r.stdout}\n${r.stderr}`);
+    const nm = path.join(profile, "node_modules", PLUGIN_ID);
+    assert.ok(fs.existsSync(path.join(nm, "lib", "index.js")), "★空壳必须被重建（空目录不许当作已挂载）");
+    assert.ok(resolveFromProfile(profile, `${PLUGIN_ID}/package.json`));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("端到端：挂载失败必须中止安装，且**不写** patch（宁可不装，也不能写出起不来的 profile）", async (t) => {
+  if (typeof process.getuid === "function" && process.getuid() === 0) return; // root 不受权限位约束
+  // Windows 的 chmod 只改只读属性、**不限制目录写入**，制造不出"必然失败"的落盘环境。
+  // 该场景由上面三条注入式 fs 代理用例覆盖（含"全失败必须抛错"）。
+  if (process.platform === "win32") { t.skip("Windows 无 POSIX 权限位语义"); return; }
+  const root = tmpDir();
+  try {
+    const profile = makeProfile(root);
+    const nmDir = path.join(profile, "node_modules");
+    fs.mkdirSync(nmDir, { recursive: true });
+    fs.chmodSync(nmDir, 0o500); // 只读：symlink 与 cpSync 都必然失败
+    try {
+      const r = await runInstaller(["plugin"], { DSH_PROFILE_DIR: profile });
+      assert.equal(r.code, 1, `应中止安装（非 0 退出）：${r.stdout}\n${r.stderr}`);
+      assert.match(r.stderr, /已中止安装/, "必须明确告知已中止");
+      const patch = fs.readFileSync(path.join(profile, "cordis.patch.yml"), "utf8");
+      assert.ok(!/dsh-remote-web/.test(patch), "★绝不能写激活行：那会让 dsh web 起不来");
+      assert.ok(!/插件已就绪/.test(r.stdout), "不得谎报成功");
+    } finally {
+      fs.chmodSync(nmDir, 0o700);
+    }
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ─────────────── ④ 自救入口：repair ───────────────
+
+test("repair：空壳现场能被修好，并打印挂载诊断三行", async () => {
+  const root = tmpDir();
+  try {
+    const profile = makeProfile(root);
+    await runInstaller(["plugin"], { DSH_PROFILE_DIR: profile });
+    // 破坏：把链接换成空壳（= 用户中招后的现场）
+    const nm = path.join(profile, "node_modules", PLUGIN_ID);
+    fs.rmSync(nm, { recursive: true, force: true });
+    fs.mkdirSync(nm, { recursive: true });
+
+    const r = await runInstaller(["repair"], { DSH_PROFILE_DIR: profile });
+    assert.equal(r.code, 0, `repair 应成功：${r.stdout}\n${r.stderr}`);
+    assert.match(r.stdout, /\[link\]/, "应打印链接诊断");
+    assert.match(r.stdout, /\[resolve\]/, "应打印解析诊断");
+    assert.match(r.stdout, /\[client\]/, "应打印客户端半声明诊断");
+    assert.match(r.stdout, /🛟/, "挂载不可用时应先摘掉激活行保命");
+    assert.ok(fs.existsSync(path.join(nm, "lib", "index.js")), "★应修好挂载");
+    assert.ok(resolveFromProfile(profile, `${PLUGIN_ID}/package.json`), "★应可解析");
+    assert.match(fs.readFileSync(path.join(profile, "cordis.patch.yml"), "utf8"), /dsh-remote-web/, "应恢复激活行");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("repair：本地插件目录缺失时明确报错并给重装命令（不静默成功）", async () => {
+  const root = tmpDir();
+  try {
+    const profile = makeProfile(root);
+    const r = await runInstaller(["repair"], { DSH_PROFILE_DIR: profile });
+    assert.equal(r.code, 1, `无本地拷贝应失败：${r.stdout}\n${r.stderr}`);
+    assert.match(r.stderr, /请重新安装/, "必须给出可照抄的重装命令");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ─────────────── ⑤ 包管理器识别（Windows 上 `command -v` 恒失效） ───────────────
+
+test("detectPackageManager：按声明文件识别，且代码里不得再用 command -v pnpm", () => {
+  const src = fnSrc("detectPackageManager", "/**\n * 市场装法下把插件包升到最新");
+  const detect = new Function("fs", "path", "spawnSync", "process", `${src}; return detectPackageManager;`)(
+    fs, path, () => ({ status: 1 }), process);
+
+  const root = tmpDir();
+  try {
+    const a = path.join(root, "a"); fs.mkdirSync(a);
+    fs.writeFileSync(path.join(a, "pnpm-workspace.yaml"), "packages: []\n");
+    assert.equal(detect(a), "pnpm", "有 pnpm-workspace.yaml → pnpm");
+
+    const b = path.join(root, "b"); fs.mkdirSync(b);
+    fs.writeFileSync(path.join(b, "package-lock.json"), "{}");
+    assert.equal(detect(b), "npm", "有 package-lock.json → npm");
+
+    const c = path.join(root, "c"); fs.mkdirSync(c);
+    assert.equal(detect(c), "pnpm", "都探测不到时兜底 pnpm（dsh profile 默认就是 pnpm）");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+
+  // 源码契约：不得再用 POSIX 内建 `command -v`（Windows 走 cmd.exe，永远命中 || 分支）
+  const codeLines = SETUP_SRC.split("\n").filter((l) => !/^\s*(\/\/|\*|\/\*)/.test(l));
+  assert.ok(!codeLines.some((l) => /command -v pnpm/.test(l)), "不得再用 command -v pnpm 探测");
+  assert.ok(/const pm = detectPackageManager\(profileDir\);/.test(SETUP_SRC), "升级路径必须用 detectPackageManager");
+});
+
+// ─────────────── ⑥ 源码契约：策略顺序与失败即中止 ───────────────
+
+test("源码契约：Windows 首选 junction（不用 'dir'），且每支之间清理残留", () => {
+  const fn = fnSrc("ensurePluginLinked", "/**\n * 独立验收：复刻 dsh 客户端模块系统的真实动作");
+  const winBranch = fn.slice(fn.indexOf('process.platform === "win32"'), fn.indexOf('["copy"'));
+  assert.ok(winBranch.includes('"junction"'), "Windows 首选必须是 junction");
+  assert.ok(!/"dir"/.test(winBranch), "★Windows 分支不得再尝试 symlinkSync(...,'dir')");
+  assert.ok(/fs\.rmSync\(nmPlugin, \{ recursive: true, force: true \}\);\s*\}\s*catch/.test(fn) || /rmSync\(nmPlugin[^\n]*\n/.test(fn),
+    "每次尝试前必须清残留（否则下一支撞 EEXIST）");
+  assert.ok(/for \(const \[how, run\] of attempts\)/.test(fn), "必须是「逐支验证」的循环，而不是 try 嵌套 catch");
+  assert.ok(/throw new Error\(`插件挂载失败/.test(fn), "全部失败必须抛错");
+  // POSIX 行为保持不变（原生 symlink 无需特权）
+  const posixBranch = fn.slice(fn.indexOf(':\n    [') >= 0 ? fn.indexOf(':\n    [') : fn.indexOf('['), fn.indexOf("const failures"));
+  assert.ok(/"dir"/.test(posixBranch), "POSIX 仍用原生 symlink");
+});
+
+test("源码契约：调用方必须检查结果并在失败时中止（老代码丢返回值还报成功）", () => {
+  // 调用必须被 try/catch 包住（老代码是裸调用 + 丢返回值）
+  assert.ok(/try \{\s*\n\s*ensurePluginLinked\(profileDir, pluginLocalDir\);/.test(SETUP_SRC),
+    "ensurePluginLinked 必须在 try 里调用（否则失败会变成未捕获异常）");
+  const call = SETUP_SRC.slice(SETUP_SRC.indexOf("try {\n    ensurePluginLinked(profileDir, pluginLocalDir);"), SETUP_SRC.indexOf("const r = ensurePatchActivation"));
+  assert.ok(/catch \(e\) \{[\s\S]*?process\.exit\(1\);/.test(call), "挂载失败必须 process.exit(1)");
+  // 顺序（只在 activateLocalCopy 函数体内看）：挂载 → 独立验收 → 才 declarePluginDep / 写 patch
+  const body = SETUP_SRC.slice(
+    SETUP_SRC.indexOf("function activateLocalCopy("),
+    SETUP_SRC.indexOf("function convergePluginActivation("));
+  assert.ok(body.length > 0, "应能定位 activateLocalCopy");
+  const order = [
+    "ensurePluginLinked(profileDir, pluginLocalDir)",
+    "const probe = probePluginResolve(profileDir);",
+    "declarePluginDep(pkgFile);",
+    "ensurePatchActivation(patchFile",
+  ];
+  let last = -1;
+  for (const marker of order) {
+    const i = body.indexOf(marker);
+    assert.ok(i > last, `activateLocalCopy 内的顺序必须是：挂载 → 验收 → 依赖 → 激活（${marker}）`);
+    last = i;
+  }
+  assert.ok(/function probePluginResolve\(/.test(SETUP_SRC), "应有独立验收（复刻 dsh 的裸包名解析）");
+});

package/packages/dsh-remote-web/test/plugin-manifest.test.mjs

@@ -122,7 +122,9 @@ test("失败归因：客户端白名单必须与服务端逐字一致，且事
   for (const c of codes) assert.ok(out.queued.includes(c), `客户端 failCodes 应含 ${c}`);
 
   // ② 与服务端白名单**集合级**一致（少一个码 = 上报被丢弃、多一个 = 服务端拒收）
-  const serverPath = join(REPO, "..", "dsh-relay-enterprise", "relay-enterprise", "src", "api.js");
+  // 可选:把服务端 api.js 的路径通过环境变量给出,即可做「客户端↔服务端白名单」集合级对拍。
+  // 未设置时跳过(跨仓库对拍属于本地/CI 场景,不应把另一仓库的位置硬编码进本仓库)。
+  const serverPath = process.env.DSH_TELEMETRY_SERVER_API || "";
   if (existsSync(serverPath)) {
     const apiSrc = readFileSync(serverPath, "utf8");
     const block = /const TELEMETRY_FAIL_CODES = new Set\(\[([\s\S]*?)\]\);/.exec(apiSrc);

package/packages/dsh-remote-web/test/quota-absent.test.mjs

@@ -0,0 +1,94 @@
+// 「中继不提供额度接口」时的降级回归。
+//
+// 背景：插件是**开源侧产物，自建与 SaaS 两种模式共用**。自建中继不限制带宽与流量，
+// 也不提供 `/_quota`；此时面板必须：
+//   ① 代理不报错（返回 {ok:true, quota:null} 而不是 5xx）；
+//   ② 不显示任何**服务端并未下发的**限制文案（例如硬编码的“本月流量限额 1GB”）。
+//
+// 曾在 2026-09 修过一次：面板在拿不到额度数据时硬编码回退成
+// 「免费额度: 带宽 ≈1Mbps · 本月流量限额 1GB」——对自建用户就是凭空捏造限制。
+import assert from "node:assert/strict";
+import http from "node:http";
+import { readFileSync } from "node:fs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { apply } from "../lib/index.js";
+
+const CLIENT_SRC = readFileSync(
+  path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "lib", "client.js"),
+  "utf8"
+);
+
+/** 假 relay：只提供 device-login；其余 404（模拟极简自建账号服务）。 */
+function startFakeRelay() {
+  const srv = http.createServer(async (req, res) => {
+    const url = new URL(req.url, "http://x");
+    const send = (code, obj) => { res.writeHead(code, { "content-type": "application/json" }); res.end(JSON.stringify(obj)); };
+    if (req.method === "POST" && url.pathname === "/api/device-login") return send(200, { token: "jwt-self" });
+    send(404, { error: { code: "not_found" } });
+  });
+  return new Promise((r) => srv.listen(0, "127.0.0.1", () => r({ srv, port: srv.address().port })));
+}
+
+/** 假中继：**没有 `/_quota`**（干净自建中继就是这样）。 */
+function startFakeRelayRouter() {
+  const srv = http.createServer((_req, res) => { res.writeHead(404); res.end(); });
+  return new Promise((r) => srv.listen(0, "127.0.0.1", () => r({ srv, port: srv.address().port })));
+}
+
+test("中继无 /_quota：代理返回 {ok:true,quota:null} 且不报错", async () => {
+  const relay = await startFakeRelay();
+  const router = await startFakeRelayRouter();
+  const tempDir = await mkdtemp(path.join(os.tmpdir(), "dsh-ui-noquota-"));
+  await writeFile(path.join(tempDir, ".dsh-config.json"), JSON.stringify({
+    phone: "13800000000",
+    password: "pw",
+    device_id: "dev-selfhost0001",
+    api_url: `http://127.0.0.1:${relay.port}`,
+    tunnel_url: `ws://127.0.0.1:${router.port}`
+  }));
+
+  const routes = new Map();
+  apply({
+    webServer: { register(route) { routes.set(route.path, route.handler); return () => {}; } },
+    effect(register) { return register(); },
+    logger: { info() {}, warn() {} }
+  }, { relayDir: tempDir });
+
+  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((r) => host.listen(0, "127.0.0.1", r));
+
+  try {
+    const r = await fetch(`http://127.0.0.1:${host.address().port}/dsh-remote/quota`);
+    assert.equal(r.status, 200, "拿不到额度不应变成 5xx");
+    const body = await r.json();
+    assert.equal(body.ok, true);
+    assert.equal(body.quota, null, "中继没有额度接口 → quota 必须是 null（而不是编造一份）");
+  } finally {
+    host.close(); relay.srv.close(); router.srv.close();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("面板文案：额度数据缺失时不得断言任何限制", () => {
+  // 有额度数据 + 限量 → 才允许出现带宽/用量文案，且带宽值必须来自服务端
+  assert.match(CLIENT_SRC, /if \(quota && quota\.limit_enabled\) \{/, "有额度且限量时才展示用量");
+  assert.doesNotMatch(CLIENT_SRC, /带宽 ≈1Mbps/, "不得硬编码带宽数值，应从服务端下发");
+  assert.match(CLIENT_SRC, /quota\.max_mbps \? "带宽 ≈" \+ quota\.max_mbps/, "带宽值服务端有才写");
+  // 无额度数据 → 只说明是免费用户，不得出现硬编码的限额
+  assert.doesNotMatch(
+    CLIENT_SRC,
+    /quotaPct !== null \?[^:]*:[^"]*本月流量限额 1GB/,
+    "不得在拿不到额度时硬编码“本月流量限额 1GB”"
+  );
+  assert.doesNotMatch(CLIENT_SRC, /:\s*" · 本月流量限额 1GB"/, "硬编码限额回退已移除");
+  // 中继报告「不限量」时也不该说限额
+  assert.match(CLIENT_SRC, /免费用户 · 当前不限速、不限流量/, "不限量应如实说明");
+});

package/packages/dsh-remote-web/test/settings-entry.test.mjs

@@ -207,7 +207,7 @@ test("登录态账号区：无「切换账号」，有「退出登录」，头
   const points = [
     "📱 远程访问：用手机或另一台电脑的浏览器，随时随地使用同一份 dsh web——人在哪都能用（免公网 IP、免内网穿透）；官方托管中继，4G/5G 即用，也可自建服务。",
     "🛠 电脑端一键安装：bridge 与「远程访问」面板一次到位——云端/自建切换、账号登录、bridge 启停、一次性扫码访问、已授权设备管理、意见反馈都在这里。",
-    "🔒 安全与通道：HTTP / WebSocket 全量透传，一次性访问密钥认证，面板实时显示设备与已授权设备列表；服务端可配置流量配额。",
+    "🔒 安全与通道：HTTP / WebSocket 全量透传，一次性访问密钥认证，面板实时显示设备与已授权设备列表。",
     "🛡 端到端加密：手机↔电脑之间的消息内容用「你的账号密码派生密钥」端到端加密——密钥与密码不落服务端（仅存校验值），中继只可见路径/大小/时间（详见 README「安全与隐私」）。",
   ];
   for (const p of points) {

package/packages/dsh-remote-web/test/telemetry.test.mjs

@@ -1,7 +1,7 @@
 // 匿名装机/连接遥测（客户端半）回归 —— 契约 + 隐私边界（2026-09）。
 //
-// 现场（2026-09 生产数据）：11 个新注册用户里只有 3 人把设备连上——6 人电脑端从未安装、2 人装了但
-// bridge 没连上；而「装不上」的人没有任何账号、也就没有任何数据，「本地 OK、新机器失败」无法归因。
+// 现场：新注册用户里只有少数把设备连上，多数卡在电脑端安装这一步；而「装不上」的人
+// 往往没有账号、也就没有任何数据，「本地 OK、新机器失败」无法归因。
 // 本用例锁死这条补上的通道：
 //   ① 触发点正确：plugin_loaded / install_started / install_failed(fail_code) / runtime_ready /
 //      bridge_started / bridge_registered / tunnel_disconnected / first_remote_ok(只一次) / panel_opened；