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

package/dsh-setup.mjs

@@ -161,6 +161,7 @@ function printHelp() {
   dsh-remote run          前台运行 bridge（调试）
   dsh-remote status       查看配置与服务状态
   dsh-remote plugin       手动安装 dsh web 远程控制插件（--uninstall 卸载）
+  dsh-remote repair       修复插件挂载（dsh web 起不来时用；只碰 profile，不联网）
   dsh-remote --help       显示本用法（等同 dsh-remote help）
 
 自建模式（可选）:
@@ -1473,34 +1474,143 @@ function copyPluginIntoProfile(profileDir, pluginDir) {
 }
 
 /** 把插件挂到 <profile>/node_modules/<PLUGIN_ID>(裸包名解析需要),指向拷贝目录;缺失/指错时重建。 */
+/**
+ * 判定 `node_modules/<PLUGIN_ID>` 是否**真的可用**。
+ *
+ * 判据绝不是"函数有没有抛错" —— 这是 0.6.7-beta.1 在 Windows 上翻车的根因：
+ * 非特权进程 + 开发者模式关闭时，`fs.symlinkSync(target, path, "dir")` 会**既不抛错也产不出可用链接**
+ * （实测：用户目录下留下一个空目录；%TEMP% 下什么都不留；同一位置两次运行一次报成功一次抛 UNKNOWN）。
+ * 于是"用 try/catch 探测能力"这个前提在 Windows 上根本不成立，写在其 catch 里的 junction 兜底永不执行。
+ *
+ * 这里只认 dsh 自己那条解析路径能不能走通：
+ *   ① 读得到 package.json 且 name 正确（cordis 加载器 + @deepseek-ai/dsh-client-modules 靠它读 dsh.client）；
+ *   ② 读得到 lib/index.js（节点半入口）；
+ *   ③ 要么 realpath 指回本地拷贝目录（链接形态），要么入口内容与本地拷贝逐字节一致（整目录拷贝形态）。
+ */
+function pluginLinkUsable(nmPlugin, pluginLocalDir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(nmPlugin, "package.json"), "utf8"));
+    if (pkg.name !== PLUGIN_ID) return false;
+    if (!fs.existsSync(path.join(nmPlugin, "lib", "index.js"))) return false;
+  } catch { return false; }
+
+  let real = "";
+  try { real = fs.realpathSync(nmPlugin); } catch { /* 悬空链接 */ }
+  if (real) {
+    try { if (real === fs.realpathSync(pluginLocalDir)) return true; } catch { /* 本地目录不在 → 看内容 */ }
+  }
+  try {
+    return fs.readFileSync(path.join(nmPlugin, "lib", "index.js"), "utf8")
+      === fs.readFileSync(path.join(pluginLocalDir, "lib", "index.js"), "utf8");
+  } catch { return false; }
+}
+
+/**
+ * 把插件挂到 `<profile>/node_modules/<PLUGIN_ID>`。
+ *
+ * 规格：已就绪返回 false（幂等）、重建成功返回 true、**任何情况下都没能挂好就抛错**。
+ * 抛错是刻意的 —— 调用方必须据此中止安装：写进 patch 的激活行会让 dsh web 按裸包名解析这个目录，
+ * 解析不到就 `Cannot find package '...\node_modules\dsh-remote-web\index.js'`，
+ * 而 cordis 的插件树加载失败 = **整个 dsh web 起不来**（用户连面板都打不开，没有自助修复入口）。
+ * 宁可不装，也不能写出一个起不来的 profile。
+ */
 function ensurePluginLinked(profileDir, pluginLocalDir) {
   const nmDir = path.join(profileDir, "node_modules");
   const nmPlugin = path.join(nmDir, PLUGIN_ID);
+  if (!fs.existsSync(path.join(pluginLocalDir, "package.json"))) {
+    throw new Error(`本地插件拷贝缺失或不完整：${pluginLocalDir}（应含 package.json）`);
+  }
   fs.mkdirSync(nmDir, { recursive: true });
   // 清理历史名链接（node_modules/dsh-remote-ui），避免解析到旧拷贝
   for (const id of PLUGIN_LEGACY_IDS) {
     try { fs.rmSync(path.join(nmDir, id), { recursive: true, force: true }); } catch { /* ignore */ }
   }
+  if (pluginLinkUsable(nmPlugin, pluginLocalDir)) return false; // 已就绪（拷贝形态也算就绪）
+
+  // ⚠️ Windows 上**不要用 symlinkSync(...,'dir')**：非特权进程下它产不出可用链接，
+  //    而且抛不抛错不确定、失败时还会留下空目录残留 —— 兜底链会因此整条失效（实测）。
+  //    junction（目录联接）免特权、realpath 正确、require.resolve 与 ESM 裸包名解析都正常。
+  const attempts = process.platform === "win32"
+    ? [
+        ["junction", () => fs.symlinkSync(path.resolve(pluginLocalDir), nmPlugin, "junction")], // junction 只接受绝对路径
+        ["copy", () => fs.cpSync(pluginLocalDir, nmPlugin, { recursive: true })],
+      ]
+    : [
+        ["dir", () => fs.symlinkSync(pluginLocalDir, nmPlugin, "dir")],
+        ["copy", () => fs.cpSync(pluginLocalDir, nmPlugin, { recursive: true })],
+      ];
+
+  const failures = [];
+  for (const [how, run] of attempts) {
+    // 每支开始前先清残留：上一支"没抛错但留了个空目录"时，不清就会让下一支撞 EEXIST 而失败
+    //（这正是原实现三级兜底退化成一级的原因）。
+    try { fs.rmSync(nmPlugin, { recursive: true, force: true }); } catch { /* ignore */ }
+    let err = null;
+    try { run(); } catch (e) { err = e; }
+    if (pluginLinkUsable(nmPlugin, pluginLocalDir)) return true;
+    failures.push(`${how}: ${err ? err.message : "未抛错但落盘结果不可用（读不到 package.json / lib/index.js）"}`);
+  }
+  throw new Error(`插件挂载失败：${nmPlugin}\n   ${failures.join("\n   ")}`);
+}
+
+
+/**
+ * 独立验收：复刻 dsh 客户端模块系统的真实动作 —— 从 profile 目录按**裸包名**解析到本插件。
+ *
+ * 与 pluginLinkUsable 是两道独立的闸门：前者看文件在不在、是不是真指向目标；
+ * 这条走 Node 的解析器（exports 字段、symlink 跟随、pnpm 布局），是"面板能不能被注入"的前提
+ * （@deepseek-ai/dsh-client-modules 就是 require.resolve('<name>/package.json') 读 dsh.client）。
+ */
+function probePluginResolve(profileDir) {
+  const base = path.join(profileDir, "__dsh_resolve_probe.cjs");
+  // 必须**另起一个 node 进程**做这次解析，不能在本进程里 require.resolve：
+  // 实测（Node 25 / macOS）：本进程里只要先失败过一次裸包名解析（例如"修复前诊断"那次），
+  // 链接随后修好了，同一个进程里的裸包名解析**仍会持续失败**（子路径却正常）——
+  // 进程内的解析缓存会把假阴性一直带下去，让"修复后验收"误判成没修好、拒绝恢复激活。
+  // 另起进程同时也更忠实：dsh 启动时就是在一个全新进程里解析这些裸包名的。
+  const script = [
+    'const { createRequire } = require("node:module");',
+    `const req = createRequire(${JSON.stringify(base)});`,
+    "process.stdout.write(JSON.stringify({",
+    `  pkgPath: req.resolve(${JSON.stringify(`${PLUGIN_ID}/package.json`)}),`,
+    `  entry: req.resolve(${JSON.stringify(PLUGIN_ID)})`,
+    "}));",
+  ].join("\n");
   try {
-    if (fs.realpathSync(nmPlugin) === pluginLocalDir) return false;
-  } catch { /* 缺失/悬空 → 重建 */ }
-  try { fs.rmSync(nmPlugin, { recursive: true, force: true }); } catch { /* ignore */ }
-  try {
-    fs.symlinkSync(pluginLocalDir, nmPlugin, "dir");
-  } catch {
-    // Windows：普通目录符号链接需要管理员或"开发者模式"，非管理员时直接 EPERM。
-    // junction（目录联接）**不需要任何特权**，且 realpath 同样解析到目标，
-    // 所以放在符号链接与整目录拷贝之间——能让 Windows 用户也拿到"链接"语义（改一处即生效）。
-    let linked = false;
-    if (process.platform === "win32") {
-      try {
-        fs.symlinkSync(path.resolve(pluginLocalDir), nmPlugin, "junction"); // junction 只接受绝对路径
-        linked = true;
-      } catch { /* 退化到拷贝 */ }
+    const r = spawnSync(process.execPath, ["-e", script], { encoding: "utf8", timeout: 30_000, windowsHide: true });
+    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)) || "解析失败";
+      return { ok: false, reason: line.trim().slice(0, 200) };
     }
-    if (!linked) fs.cpSync(pluginLocalDir, nmPlugin, { recursive: true });
+    const out = JSON.parse(String(r.stdout || "{}"));
+    const pkg = JSON.parse(fs.readFileSync(out.pkgPath, "utf8"));
+    return {
+      ok: true,
+      pkgPath: out.pkgPath,
+      entry: out.entry,
+      name: pkg.name,
+      clientPlatform: (pkg.dsh && pkg.dsh.client && pkg.dsh.client.platform) || "",
+    };
+  } catch (e) {
+    return { ok: false, reason: `${e.code || e.name}: ${e.message}` };
   }
-  try { return fs.realpathSync(nmPlugin) === pluginLocalDir; } catch { return false; }
+}
+
+/**
+ * 描述插件在 profile 里的挂载形态（供 status / repair 输出）。
+ * 用户报障时这三行就能区分"链接坏了"与"别的毛病"——不必再靠猜。
+ * @returns {{localExists:boolean, exists:boolean, usable:boolean, kind:"missing"|"broken"|"linked"|"copy"|"no-local-copy"}}
+ */
+function describePluginLink(profileDir) {
+  const nmPlugin = path.join(profileDir, "node_modules", PLUGIN_ID);
+  const localDir = path.join(profileDir, PLUGIN_LOCAL_DIR);
+  const localExists = fs.existsSync(path.join(localDir, "package.json"));
+  if (!fs.existsSync(nmPlugin)) return { localExists, exists: false, usable: false, kind: localExists ? "missing" : "no-local-copy" };
+  const usable = pluginLinkUsable(nmPlugin, localDir);
+  let isLink = false;
+  try { isLink = fs.lstatSync(nmPlugin).isSymbolicLink(); } catch { /* ignore */ }
+  return { localExists, exists: true, usable, kind: usable ? (isLink ? "linked" : "copy") : "broken" };
 }
 
 /** package.json 写入 file: 依赖(让后续任何 pnpm/npm install 也认可该插件,不会删链接)。 */
@@ -1564,8 +1674,26 @@ function activateLocalCopy(profileDir, pkgFile, patchFile, pluginDir, patch, pkg
     console.error(`❌ 插件入口缺失：${entryFile}（本包不完整？请用官方源重装：npx --registry=https://registry.npmjs.org @mrrisega/dsh-remote@latest）`);
     process.exit(1);
   }
+  // ⚠️ 顺序与"失败即中止"都是刻意的（0.6.7-beta.1 Windows 实测事故）：
+  //   老代码把 ensurePluginLinked 的返回值丢掉、patch 照写、还打印「✅ 插件已就绪」，
+  //   于是用户拿到的是**起不来的 dsh web**（cordis 按裸包名解析到空目录 → plugin tree failed to load，
+  //   整个 dsh web 启动失败，而面板/插件市场都在那个进程里 → 用户没有任何自助修复入口）。
+  //   现在：先挂载 → 独立验收 → 才写依赖与激活行；任何一步不过就中止，绝不留下坏 profile。
+  try {
+    ensurePluginLinked(profileDir, pluginLocalDir);   // node_modules 链接(name 才能被解析)
+  } catch (e) {
+    console.error(`❌ ${e.message}`);
+    console.error("   已中止安装：继续写 patch 会让 dsh web 因插件树加载失败而完全无法启动。");
+    console.error("   请把上面的错误整段反馈给作者（含平台 / 是否管理员 / 开发者模式是否开启）。");
+    process.exit(1);
+  }
+  const probe = probePluginResolve(profileDir);
+  if (!probe.ok) {
+    console.error(`❌ 验收失败：dsh 无法从 profile 按裸包名解析 ${PLUGIN_ID}（${probe.reason}）`);
+    console.error("   已中止安装（未写 patch）：否则 dsh web 会因插件树加载失败而完全无法启动。");
+    process.exit(1);
+  }
   declarePluginDep(pkgFile);                        // file: 依赖(包管理器 install 不误删)
-  ensurePluginLinked(profileDir, pluginLocalDir);    // node_modules 链接(name 才能被解析)
   const r = ensurePatchActivation(patchFile, pluginLocalDir, pkgFile, { forcePatch: !!opts.forcePatch });
   if (r.ok) {
     console.log(`✅ 插件已就绪: ${pluginLocalDir}${opts.forcePatch ? "（激活点已转为 patch 行，装完即热加载）" : ""}`);
@@ -1602,6 +1730,34 @@ function readInstalledPluginVersion(profileDir, name) {
   } catch { return null; }
 }
 
+/**
+ * 识别 profile 用哪个包管理器（市场装法「一键更新」要用它改源码）。
+ *
+ * ⚠️ 不能用 `sh("command -v pnpm && echo pnpm || echo npm")`：`sh()` 走 execSync，
+ * Windows 下是 cmd.exe，而 `command` 是 POSIX 内建 → 永远命中 `||` 分支，
+ * **Windows 上永远选 npm**。而 dsh profile 是 pnpm 管理的（pnpm-workspace.yaml + 虚拟 store），
+ * 用 npm 去改同一个 node_modules 会写出与 pnpm 不同的布局（污染/冲突风险）。
+ * 现在：先用**声明文件**判断（最可靠、零子进程），再用 where/which 探测可执行文件；
+ * 兜底选 pnpm 而不是 npm —— dsh profile 默认就是 pnpm，选错方向的代价不对称。
+ */
+function detectPackageManager(profileDir) {
+  try {
+    if (fs.existsSync(path.join(profileDir, "pnpm-lock.yaml"))
+      || fs.existsSync(path.join(profileDir, "pnpm-workspace.yaml"))) return "pnpm";
+    if (fs.existsSync(path.join(profileDir, "package-lock.json"))) return "npm";
+  } catch { /* 读不到就往下探测 */ }
+  const has = (bin) => {
+    try {
+      return process.platform === "win32"
+        ? spawnSync("where", [bin], { stdio: "ignore", windowsHide: true }).status === 0
+        : spawnSync("sh", ["-c", `command -v ${bin}`], { stdio: "ignore" }).status === 0;
+    } catch { return false; }
+  };
+  if (has("pnpm")) return "pnpm";
+  if (has("npm")) return "npm";
+  return "pnpm";
+}
+
 /**
  * 市场装法下把插件包升到最新。
  *
@@ -1615,7 +1771,7 @@ function readInstalledPluginVersion(profileDir, name) {
 function upgradeMarketManagedPlugin(profileDir, name, dep) {
   const spec = String(dep ?? "").trim();
   const isRegistryRange = /^[\^~><=v\d]/.test(spec);
-  const pm = sh("command -v pnpm >/dev/null 2>&1 && echo pnpm || echo npm").stdout.trim() || "npm";
+  const pm = detectPackageManager(profileDir);
   const args = isRegistryRange ? `add ${name}@latest` : `update ${name}`;
   const cmd = `${pm} ${args}`;
   const r = sh(cmd, 180000, profileDir);
@@ -1734,6 +1890,83 @@ async function pluginCmd(argv) {
   // 引导语只在 setup 汇总里打印一次(这里不再重复;单独跑 `dsh-remote plugin` 也无需引导)
 }
 
+/**
+ * 打印插件挂载诊断三行（供 status / repair 共用）。
+ * 用户报障时这三行就能区分「链接坏了」与「别的毛病」，不必靠猜：
+ *   link = 有没有真挂上（junction / 符号链接 / 整目录拷贝 / BROKEN）
+ *   resolve = dsh 的裸包名解析能不能走通（浏览器半注入面板就靠它）
+ *   client = dsh.client.platform 声明在不在
+ */
+function printPluginDiagnostics(profileDir) {
+  const nmPlugin = path.join(profileDir, "node_modules", PLUGIN_ID);
+  const link = describePluginLink(profileDir);
+  const probe = probePluginResolve(profileDir);
+  const kindText = { linked: "已挂载（链接）", copy: "已挂载（整目录拷贝）", broken: "BROKEN（存在但读不到内容）", missing: "缺失", "no-local-copy": "缺失（本地插件目录也没有）" }[link.kind] || link.kind;
+  console.log(`   [link]    ${nmPlugin}\n             → ${kindText}`);
+  console.log(`   [resolve] ${PLUGIN_ID}/package.json → ${probe.ok ? probe.pkgPath : `失败（${probe.reason}）`}`);
+  console.log(`   [client]  dsh.client.platform = ${probe.ok ? (probe.clientPlatform || "缺失") : "（解析失败，无法确认）"}`);
+  return { link, probe };
+}
+
+/**
+ * `dsh-remote repair` —— 只修 profile 里的插件挂载，不碰运行环境 / 不联网 / 不碰自启动。
+ *
+ * 为什么需要这个独立入口：插件挂载坏掉时 dsh web **整个起不来**（cordis 插件树加载失败），
+ * 而设置面板与插件市场都在那个进程里 —— 用户没有任何自助修复入口，只剩命令行。
+ * 执行顺序刻意是"先保命、再修复、最后恢复激活"：
+ *   ① patch 里引用了本插件但挂载不可用 → **先把 include 摘掉**（profile 立刻恢复可启动）；
+ *   ② 再重建挂载（失败会抛错，但①的结果保留 → 用户至少能打开 dsh web）；
+ *   ③ 只有①②都成功，才把激活行写回去。
+ */
+function repairProfile(argv = []) {
+  const profileDir = resolveProfileDir(argv);
+  const pkgFile = path.join(profileDir, "package.json");
+  const patchFile = path.join(profileDir, "cordis.patch.yml");
+  const localDir = path.join(profileDir, PLUGIN_LOCAL_DIR);
+  if (!fs.existsSync(pkgFile) || !fs.existsSync(patchFile)) {
+    console.error(`❌ 未找到 dsh web profile（${profileDir}）。`);
+    console.error("   先确认 dsh web 装好并初始化过 profile，或用 --profile <目录> 指定。");
+    process.exit(1);
+  }
+  console.log(`dsh-remote repair — ${profileDir}`);
+  const before = printPluginDiagnostics(profileDir);
+  if (!before.link.localExists) {
+    console.error(`❌ 本地插件目录缺失（${localDir}）：无法就地修复。`);
+    console.error("   请重新安装：npx @mrrisega/dsh-remote@latest");
+    process.exit(1);
+  }
+
+  const patch = fs.readFileSync(patchFile, "utf8");
+  const referenced = parsePatchInsertIds(patch).ids.some((id) => PLUGIN_ALL_IDS.includes(id));
+  if (referenced && !before.link.usable) {
+    // 保命动作：先摘掉激活行，让 dsh web 至少能启动（此时插件不可用，但用户进得去、能重装）
+    stripIncludeEntries(patchFile, patch, "挂载不可用，先摘掉 include 保命");
+    try { removeBundleEntry(pkgFile); } catch { /* ignore */ }
+    console.log("🛟 挂载不可用 → 已先摘掉插件激活行（dsh web 现在应该能启动了）。");
+  }
+
+  try {
+    ensurePluginLinked(profileDir, localDir);
+  } catch (e) {
+    console.error(`❌ 重建挂载失败：${e.message}`);
+    console.error("   profile 已处于「能启动、插件未激活」状态；请把上面错误反馈给作者。");
+    process.exit(1);
+  }
+  const after = printPluginDiagnostics(profileDir);
+  if (!after.probe.ok) {
+    console.error("❌ 挂载已重建，但 dsh 仍解析不到本插件 —— 请把上面的输出反馈给作者。");
+    process.exit(1);
+  }
+  const srcPluginDir = path.join(THIS_DIR, "packages", PLUGIN_ID);
+  if (!fs.existsSync(srcPluginDir)) {
+    console.error(`❌ 本包缺少 packages/${PLUGIN_ID}，无法就地恢复激活行。`);
+    console.error("   请重新安装：npx @mrrisega/dsh-remote@latest");
+    process.exit(1);
+  }
+  convergePluginActivation(profileDir, pkgFile, patchFile, srcPluginDir, fs.readFileSync(patchFile, "utf8"));
+  console.log("✅ 挂载与激活已修复 —— 重启一次 dsh web 生效。");
+}
+
 // ---------- main ----------
 // 无命令名（或首个参数以 - 开头）时默认执行 setup —— 这样 `dsh-remote --no-autostart`
 // 这类「只给 flag」的用法才能装上去。
@@ -1748,6 +1981,7 @@ if (cmd === "setup" || cmd === "install") await setup(args);
 else if (cmd === "settings") settingsHint();
 else if (cmd === "run") await runBridge();
 else if (cmd === "plugin") await pluginCmd(process.argv.slice(3));
+else if (cmd === "repair") repairProfile(process.argv.slice(3));
 else if (cmd === "status") {
   const cfg = loadConfig();
   const local = Boolean(cfg.local_key);
@@ -1755,6 +1989,14 @@ else if (cmd === "status") {
   console.log("连接模式:", local ? `自建服务（${cfg.tunnel_url || "未设置服务器地址"}）` : `SaaS 云端服务（${cfg.phone || "未配置账号"}）`);
   console.log("API:", cfg.api_url || (local ? "（自建模式无需账号 API）" : DEFAULT_API));
   console.log("远程地址/登录: 打开 dsh web → 设置 → 「远程控制」查看与操作");
+  // 插件挂载诊断：报障时一眼看出是"链接坏了"还是"别的毛病"
+  const profileDir = resolveProfileDir([]);
+  if (fs.existsSync(path.join(profileDir, "package.json"))) {
+    console.log("插件挂载:");
+    printPluginDiagnostics(profileDir);
+  } else {
+    console.log(`插件挂载: 未找到 profile（${profileDir}）`);
+  }
 } else {
   printHelp();
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrrisega/dsh-remote",
-  "version": "0.6.7-beta.1",
+  "version": "0.6.7-beta.2",
   "description": "手机远程控制 DeepSeek Harness · Remote control DeepSeek Harness (dsh web) from any phone browser — 100% 全功能 App 级体验：发消息、看工具执行、审批权限、改设置、管凭据，含特权操作，免内网穿透。一条命令安装 npx @mrrisega/dsh-remote。Mobile remote control for DSH, self-host or SaaS, no server needed on LAN.",
   "keywords": [
     "deepseek-harness",

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

@@ -2302,7 +2302,7 @@ const PLUGIN_ID = "dsh-remote-web";
 const PLUGIN_LEGACY_IDS = ["dsh-remote-ui"];
 const PLUGIN_ALL_IDS = [PLUGIN_ID, ...PLUGIN_LEGACY_IDS];
 /** 插件自身发布版本（与 dsh-remote 根包同步递增）。 */
-const PLUGIN_VERSION = "0.6.7-beta.1";
+const PLUGIN_VERSION = "0.6.7-beta.2";
 const UPDATE_LOG = ".dsh-update.log";
 const UPDATE_MARKER = ".dsh-update-running";
 

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

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.6.7-beta.1",
+  "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/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 的裸包名解析）");
+});