@mrrisega/dsh-remote 0.6.9 → 0.6.10-beta.2

package/packages/dsh-remote-web/test/activation-single-point.test.mjs

@@ -0,0 +1,104 @@
+/**
+ * 激活点唯一性 —— 配置不变量 + 安装器方向守护。
+ *
+ * 背景（2026-09-22 实测事故）：插件被两处同时激活时，dsh web **启动即挂**：
+ *   `duplicate loader entry id: dsh-remote-web` → `plugin tree failed to load`。
+ * 不是"插件不生效"，是**dsh 起不来**。
+ *
+ * 两处激活来自：① `dsh.profile.bundles` 里有插件自带 bundle；② profile 的
+ * `cordis.patch.yml` 里又有激活行。而**自动维护流程会周期性把 bundle 写回** bundles，
+ * 所以"删 bundles、留 patch"的修法会被撤销 → 又变两处 → 再崩。
+ *
+ * 稳定方向只有一个（本文件就是把它钉死）：
+ *   **bundle 归包管理器管、我们不动它；我们保证自己不写第二个激活点。**
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { activationPoints, checkInvariant } from "../../../scripts/check-profile-activation.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const SETUP_SRC = readFileSync(join(HERE, "..", "..", "..", "dsh-setup.mjs"), "utf8");
+
+/** 造一个假 profile 目录。 */
+function fakeProfile({ bundles = [], patch = "" } = {}) {
+  const dir = mkdtempSync(join(tmpdir(), "dsh-act-"));
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "p", dsh: { profile: { bundles } } }));
+  writeFileSync(join(dir, "cordis.patch.yml"), patch);
+  return dir;
+}
+
+const PATCH_ROW = `- insert:\n    - id: dsh-remote-web\n      name: 'dsh-remote-web'\n`;
+
+test("不变量:只有 bundles 一处 → 成立", () => {
+  const dir = fakeProfile({ bundles: ["dsh-remote-web"], patch: "# 空 patch\n" });
+  const hits = activationPoints(dir);
+  assert.equal(hits.length, 1);
+  assert.equal(hits[0].source, "bundles");
+});
+
+test("★ 不变量红灯:bundles + patch 两处 → 必须判违规(dsh web 会启动即挂)", () => {
+  const dir = fakeProfile({ bundles: ["dsh-remote-web"], patch: PATCH_ROW });
+  const hits = activationPoints(dir);
+  assert.equal(hits.length, 2, "两处激活必须被数出来");
+  assert.deepEqual(hits.map((h) => h.source).sort(), ["bundles", "patch"]);
+  const r = checkInvariant([dir]);
+  assert.equal(r.ok, false, "两处激活必须让不变量检查变红");
+  assert.equal(r.violations.length, 1);
+});
+
+test("不变量:只有 patch 一处 → 成立(插件不在 bundles 时的正常形态)", () => {
+  const dir = fakeProfile({ bundles: [], patch: PATCH_ROW });
+  assert.equal(activationPoints(dir).length, 1);
+  assert.equal(checkInvariant([dir]).ok, true);
+});
+
+test("不变量:历史 id(dsh-remote-ui)的遗留激活行也要被数出来(改过名同样会撞)", () => {
+  const dir = fakeProfile({ bundles: ["dsh-remote-ui"], patch: "- insert:\n    - id: dsh-remote-ui\n      name: 'dsh-remote-ui'\n" });
+  assert.equal(activationPoints(dir).length, 2);
+});
+
+test("不变量:未启用本插件 → 0 个激活点,也算成立", () => {
+  const dir = fakeProfile({ bundles: ["other-plugin"], patch: "- insert:\n    - id: other-plugin\n" });
+  assert.equal(activationPoints(dir).length, 0);
+  assert.equal(checkInvariant([dir]).ok, true);
+});
+
+test("★ 安装器方向守护:ensurePatchActivation 绝不得再调 removeBundleEntry(方向反了)", () => {
+  // 取 ensurePatchActivation 的函数体(按大括号配平)
+  const start = SETUP_SRC.indexOf("function ensurePatchActivation(");
+  assert.notEqual(start, -1, "找不到 ensurePatchActivation");
+  // ⚠️ 不能直接找第一个 `{` —— 签名里的 `opts = {}` 会立刻把它配平,取到空体。
+  //   必须先找到**参数列表的右括号**,再从它之后找函数体的左花括号。
+  const parenOpen = SETUP_SRC.indexOf("(", start);
+  let pd = 0, parenClose = -1;
+  for (let i = parenOpen; i < SETUP_SRC.length; i++) {
+    if (SETUP_SRC[i] === "(") pd++;
+    else if (SETUP_SRC[i] === ")") { pd--; if (pd === 0) { parenClose = i; break; } }
+  }
+  assert.notEqual(parenClose, -1, "参数列表不配平");
+  const open = SETUP_SRC.indexOf("{", parenClose);
+  let depth = 0, end = -1;
+  for (let i = open; i < SETUP_SRC.length; i++) {
+    if (SETUP_SRC[i] === "{") depth++;
+    else if (SETUP_SRC[i] === "}") { depth--; if (depth === 0) { end = i; break; } }
+  }
+  assert.notEqual(end, -1, "函数体不配平");
+  const body = SETUP_SRC.slice(open, end + 1);
+  assert.equal(
+    /removeBundleEntry\s*\(/.test(body),
+    false,
+    "ensurePatchActivation 里不得再出现 removeBundleEntry：那条路是「删 bundles、留 patch」，" +
+      "而维护流程会把 bundle 写回 → 又变两处激活 → dsh web 启动即崩。稳定方向是留 bundle、删 patch 行。"
+  );
+  // 必须真的在"插件已在 bundles"时早退并声明 bundleOnly
+  assert.match(body, /inBundles\.length/, "必须先判断插件是否已在 bundles");
+  assert.match(body, /bundleOnly:\s*true/, "必须在 bundles 命中时以 bundleOnly 早退");
+  // 并清理历史遗留的重复 patch 行（收敛到单点）
+  assert.match(body, /stripPluginEntries\(/, "必须顺手清掉历史遗留的重复 patch 行");
+});

package/packages/dsh-remote-web/test/patch-activation.test.mjs

@@ -182,21 +182,34 @@ test("回归护栏：plugin 子命令必须把激活结果 return 给 setup（
   assert.match(src, /pluginResult\.hotPatch/, "应据 hotPatch 判断是否走热挂载形态");
 });
 
-test("硬约束：源码归我们时**必须**把激活点从 bundles 转成 patch 行（否则热加载失效、且两处并存会崩）", () => {
-  // 事故复盘：patch 行与插件自带 bundle patch 同时生效时，dsh web 启动即
-  //   TypeError: duplicate loader entry id: dsh-remote-web
-  //   Error: dsh: plugin tree failed to load: failed to apply loader entry include (cordis:include)
-  // 所以两条激活路径必须互斥。而当装置器**要把本地这份源码装进去**时（升级/自装），
-  // 正确做法不是"保持 bundles"，而是**摘掉 bundles 条目 + 写 patch 行**：
-  //   · 只留 bundles → 只在启动时读取，装完看不到新版、也拿不到热加载（实测踩到）；
-  //   · 两处并存 → 启动即崩。
+test("★ 硬约束(2026-09-22 **方向反转**)：bundles 已在时**不得**再写 patch 行", () => {
+  // 【为什么反转 —— 这是一条被推翻的既有硬约束,不是"测试写松了"】
+  //   旧约束是「源码归我们时**必须**把激活点从 bundles 转成 patch 行」,理由是**热加载**
+  //   (装完即生效、不用重启)。但它在真实环境里暴露了代价:
+  //     自动维护流程会把插件自带 bundle **周期性写回** `dsh.profile.bundles`,
+  //     于是"删 bundles、留 patch"这个方向被不断撤销 → 又变两处激活 → dsh web 启动即
+  //       TypeError: duplicate loader entry id: dsh-remote-web
+  //       Error: dsh: plugin tree failed to load: failed to apply loader entry include
+  //   —— 注意:这不是"插件不生效",是**整个 dsh 起不来**(面板/市场都在那个进程里,
+  //      用户没有任何自助修复入口)。2026-09-22 用真实启动复现。
+  //
+  //   所以方向反转为:**bundle 归包管理器管、我们不动它**;我们只保证自己不写第二个激活点,
+  //   并把历史遗留的重复 patch 行清掉。
+  //   代价:失去热加载 → 由安装器随后触发的重启让新版生效
+  //        (activateLocalCopy 在此形态下返回 hotPatch:false,调用方会重启)。
   const profile = makeProfile({ bundles: [...PLUGIN_BUNDLES, "dsh-remote-web"] });
   const relay = join(profile, "relay");
   try {
-    const out = installPlugin(profile, relay);
-    assert.match(out, /激活点已转为 patch 行/, "应把激活点转成 patch 行（热加载）");
-    assert.equal((readPatch(profile).match(/- id: dsh-remote-web/g) || []).length, 1, "应恰好写一条 patch 行");
-    assert.ok(!readBundles(profile).includes("dsh-remote-web"), "bundles 条目必须被摘掉（单一激活点）");
+    installPlugin(profile, relay);
+    assert.equal(
+      (readPatch(profile).match(/- id: dsh-remote-web/g) || []).length,
+      0,
+      "bundles 已在时**不得**再写 patch 行 —— 那会造出第二个激活点,dsh web 启动即崩"
+    );
+    assert.ok(
+      readBundles(profile).includes("dsh-remote-web"),
+      "bundles 条目必须**保留**(那是包管理器/维护流程管的激活点,我们不去动它)"
+    );
   } finally { cleanup(profile); }
 });
 

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

@@ -81,14 +81,29 @@ 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/, "带宽值服务端有才写");
-  // 无额度数据 → 只说明是免费用户，不得出现硬编码的限额
+  // 【0.6.11 改断言】旧断言是
+  //   assert.match(CLIENT_SRC, /quota\.max_mbps \? "带宽 ≈" \+ quota\.max_mbps/, "带宽值服务端有才写")
+  // 它编码的是**旧行为**（账号卡「更多」档位明细里的「当前：带宽 ≈N Mbps」那一行），不是不变量。
+  // 业主口径：「插件面板里面不要展示『更多』里的 PRO 版本流量带宽，我看你把数字都展示出来了。
+  // 在本地的设置面板里面，把这个功能删掉。」→ 整块（renderPlanDetail + planSpecText/freeMbpsOf）
+  // 已删，那个字符串在代码里不再存在。保留下来的**不变量**（比原来更强）：
+  //   客户端不得渲染任何带宽/流量/价格**数值** —— 服务端没下发时不许编（旧约束），下发了也不摆（新口径）。
+  assert.doesNotMatch(CLIENT_SRC, /" Mbps"/, "面板不再渲染带宽数值（业主口径：本地面板不展示规格数字）");
+  assert.doesNotMatch(CLIENT_SRC, /" GB\/月，¥"/, "面板不再渲染流量/价格数值（档位明细已删）");
+  // 但「已限速 / 不限速」这条**定性**提示仍在，且仍由服务端字段驱动（只是不再带数值）——
+  // 这是上面第 ① 条不变量「服务端没说的限制一个字都不许编」的正面表达，也是必须保留的行为。
+  assert.match(CLIENT_SRC, /quota\.max_mbps \? remainText : "已限速 · " \+ remainText/, "「已限速」提示仍由服务端字段驱动（不再带数值）");
+  // 无额度数据 → 不得出现硬编码的限额（首屏文案不再挂档位名，所以这里也不再断言「免费用户」前缀）
   assert.doesNotMatch(
     CLIENT_SRC,
     /quotaPct !== null \?[^:]*:[^"]*本月流量限额 1GB/,
     "不得在拿不到额度时硬编码“本月流量限额 1GB”"
   );
   assert.doesNotMatch(CLIENT_SRC, /:\s*" · 本月流量限额 1GB"/, "硬编码限额回退已移除");
-  // 中继报告「不限量」时也不该说限额
-  assert.match(CLIENT_SRC, /免费用户 · 当前不限速、不限流量/, "不限量应如实说明");
+  // 中继报告「不限量」时也不该说限额。
+  // 【0.6.10 改断言】旧断言是 /免费用户 · 当前不限速、不限流量/ —— 那是**旧产品文案**（首屏挂档位名、
+  // 用「流量」这个词），不是不变量；业主口径改为「首页面不展示会员相关信息」「流量一律叫额度」，
+  // 所以文案变成「当前不限速、不限额度」。这里保留的**不变量**是：中继明确报告不限量时必须如实说明
+  // （下面这条分支仍在、仍由服务端字段驱动），不是那句具体措辞。
+  assert.match(CLIENT_SRC, /当前不限速、不限额度/, "不限量应如实说明（首屏不再带档位名）");
 });

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

@@ -89,7 +89,8 @@ function loadPlugin(opts = {}) {
   class MutationObserverMock { constructor() {} observe() {} disconnect() {} }
 
   const localStorage = {
-    _store: new Map(),
+    // opts.localStorageSeed：预置 key/value（如 dsh-remote-marketing-more-v1=1 → 营销入口已收纳进「更多」）
+    _store: new Map(Object.entries(opts.localStorageSeed || {})),
     getItem(k) { return this._store.has(k) ? this._store.get(k) : null; },
     setItem(k, v) { this._store.set(k, String(v)); },
     removeItem(k) { this._store.delete(k); },
@@ -409,6 +410,55 @@ test("E2EE 徽标：未登录 / host 未下发 e2ee → 不打扰（不渲染状
   assert.equal(e2eeLine(oldHost.render()), undefined, "未下发 service.e2ee 时不应渲染状态行");
 });
 
+test("「更多」只收纳营销入口：档位规格数字（Mbps / GB / 价格）不再出现在账号卡里", () => {
+  // 收纳态（localStorage 里记着用户关掉过引导）＝「更多」里会出现那两条折叠入口的场景
+  const plugin = loadPlugin({ localStorageSeed: { "dsh-remote-marketing-more-v1": "1" } });
+  plugin.states[0] = { config: { phone: "13800000000", deviceId: "dev-x" }, service: { running: true } };
+  let tree = plugin.render();
+
+  // 真实用户路径：点披露按钮展开「更多」
+  const toggle = find(tree, (n) => n.props?.id === "dru-account-more");
+  assert.ok(toggle, "账号卡应有「更多」披露按钮");
+  assert.equal(toggle.props["aria-expanded"], "false", "默认收起");
+  toggle.props.onClick();
+  tree = plugin.render();
+  const body = find(tree, (n) => n.props?.className === "dru-more-body");
+  assert.ok(body, "「更多」内容体应在 DOM 里");
+  assert.equal(body.props.hidden, false, "点击后应展开（hidden=false）");
+
+  // 【0.6.11】档位明细整块删除：标题「套餐与额度」、PRO / Pro Max 规格行、价格与结论句都不再渲染
+  assert.ok(!textHas(body, "套餐与额度"), "「套餐与额度」标题应删除");
+  assert.ok(!textHas(body, "Mbps"), "不得再渲染带宽数值（业主口径：本地面板不展示 PRO 版本流量带宽）");
+  assert.ok(!textHas(body, "GB"), "不得再渲染流量数值");
+  assert.ok(!textHas(body, "¥"), "不得再渲染价格");
+  assert.ok(!textHas(body, "以套餐页为准"), "随档位明细一起删掉的结论句不得残留");
+  // 整张账号卡同样一个规格数字都不许有
+  assert.ok(!textHas(tree, "Mbps"), "账号卡里不得出现 Mbps");
+  assert.ok(!textHas(tree, "¥"), "账号卡里不得出现价格");
+
+  // 但两条**折叠的营销入口**仍在（业主只要数字走，入口留着）
+  const upsell = find(body, (n) => n.type === "button" && (n.children || []).some((c) => typeof c === "string" && c.includes("升级 PRO")));
+  const invite = find(body, (n) => n.type === "button" && (n.children || []).some((c) => typeof c === "string" && c.includes("带新用户换会员")));
+  assert.ok(upsell, "「更多」里应保留「🚀 升级 PRO」入口");
+  assert.ok(invite, "「更多」里应保留「🎁 带新用户换会员」入口");
+  assert.equal(typeof upsell.props.onClick, "function");
+  assert.equal(typeof invite.props.onClick, "function");
+
+  // 源码级：函数与其调用都删掉了（不留死代码）。
+  // ⚠️ 断言「代码形态」而不是裸标识符 —— 注释里**故意**留着「这里原本是什么、为什么删」的说明
+  //    （与 settings-entry.test.mjs 的同款约定：注释里允许出现说明文字）。
+  assert.doesNotMatch(SOURCE, /function renderPlanDetail\(/, "renderPlanDetail 函数必须删除");
+  assert.doesNotMatch(SOURCE, /^\s*renderPlanDetail\(\),/m, "renderPlanDetail 的调用点必须删除");
+  assert.doesNotMatch(SOURCE, /function planSpecText\(/, "planSpecText 定义必须删除");
+  assert.doesNotMatch(SOURCE, /planSpecText\("/, "planSpecText 的调用必须删除");
+  assert.doesNotMatch(SOURCE, /function freeMbpsOf\(/, "freeMbpsOf 定义必须删除");
+  assert.doesNotMatch(SOURCE, /=\s*freeMbpsOf\(\)/, "freeMbpsOf 的调用必须删除");
+  assert.doesNotMatch(SOURCE, /var FREE_FACTS\s*=/, "FREE_FACTS 定义必须删除（只被 freeMbpsOf 使用）");
+  assert.doesNotMatch(SOURCE, /" Mbps"|" GB\/月，¥"/, "不得残留渲染规格数字的字符串拼接");
+  // 不变量仍在：planFactsOf 仍被 upgradePath 用来取档位展示名（不是死代码）
+  assert.match(SOURCE, /var name = planFactsOf\(key\)\.name;/);
+});
+
 test("E2EE 徽标（源码级约束）：client 含徽标字段/文案与 reason 映射表", () => {
   assert.match(SOURCE, /service\.e2ee/);
   assert.match(SOURCE, /\.e2ee-state\.json/);

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

@@ -189,6 +189,23 @@ test("入口迁移：注册 settings.section 栏目（id/order/label），移除
   assert.equal(plugin.registered.has("dsh-remote-panel"), false, "浮动配置面板不应再注册");
 });
 
+test("入口迁移：settings.section 里**只有一个**栏目（id=dsh-remote）——微信机器人不再是第二个栏目", () => {
+  const plugin = loadPlugin();
+  // 再跑一次 inject 回调（宿主重开设置页会重跑），断言不会冒出第二个栏目
+  plugin.injects.get("settings.section")();
+  const sections = [...plugin.metas.values()].filter((m) => m.name === "settings.section");
+  assert.deepEqual(sections.map((m) => m.id), ["dsh-remote"],
+    `settings.section 只应有 dsh-remote 一个栏目，实际：${sections.map((m) => m.id).join(",")}`);
+  assert.equal(plugin.metas.has("dsh-remote-wechat"), false,
+    "「🤖 微信机器人」不得再注册成独立栏目（0.6.11：搬进面板的第三个 tab「微信机器人通道」）");
+  assert.doesNotMatch(SOURCE, /dsh-remote-wechat/, "源码里也不得残留第二个栏目的 id");
+  // 搬进去之后仍然存在：面板 tab 条里的第三个 tab + 微信绿泡泡图标（行为断言见 wechat-bot-ui.test.mjs）
+  assert.match(SOURCE, /"微信机器人通道"/, "微信机器人 tab 必须在面板里");
+  assert.match(SOURCE, /dru-wx-ico/, "微信 tab 必须带绿泡泡图标 class");
+  // 槽注入次数仍是两次（settings.section + shell.overlay），没有偷偷加第三个 inject
+  assert.equal(plugin.injects.size, 2, `inject 的槽名应仍是 settings.section + shell.overlay，实际：${[...plugin.injects.keys()].join(",")}`);
+});
+
 test("登录态账号区：无「切换账号」，有「退出登录」，头部/关于卡文案为「远程访问」", () => {
   const plugin = loadPlugin();
   plugin.states[0] = { config: { phone: "13800000000", deviceId: "dev-test" }, service: { running: false } };

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

@@ -15,9 +15,10 @@
 //
 // 手法与 connect-loop.test.mjs 一致：真实分支 + PATH 上的假 launchctl/pgrep/ps/npx，绝不碰本机真实服务。
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
 import http from "node:http";
 import { chmodSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -36,7 +37,9 @@ async function waitFor(fn, { timeout = 5000, step = 10 } = {}) {
   }
 }
 
-const ALLOWED_EVENT_KEYS = new Set(["name", "at", "version", "os", "arch", "node", "fail_code"]);
+const ALLOWED_EVENT_KEYS = new Set(["name", "at", "version", "harness_version", "channel", "os", "arch", "node", "fail_code"]);
+/** 服务端 TELEMETRY_MISC_RE 的等价物：不匹配的字符串字段会被服务端静默清空。 */
+const SERVER_MISC_RE = /^[A-Za-z0-9._-]{0,32}$/;
 /** 禁止出现在遥测 payload 里的字段/取值（隐私边界；见 docs/telemetry.md「不采集什么」）。 */
 const FORBIDDEN = [
   "phone", "password", "passwd", "email", "token", "secret", "authorization", "bearer",
@@ -236,6 +239,11 @@ function assertContractRequest(req, { eventNames, failCodes }) {
     assert.equal(typeof ev.os, "string");
     assert.equal(typeof ev.arch, "string");
     assert.match(String(ev.node), /^\d+$/, "node 只能是主版本号数字字符串");
+    // 宿主 DSH 版本 + 更新通道：每条事件都必须带；值必须过服务端字符类（否则服务端会静默清空）
+    assert.equal(typeof ev.harness_version, "string", "每条事件必须带 harness_version（未知 = 空串，但不能缺字段）");
+    assert.equal(typeof ev.channel, "string", "每条事件必须带 channel（未知 = 空串，但不能缺字段）");
+    assert.match(ev.harness_version, SERVER_MISC_RE, "harness_version 必须匹配服务端 TELEMETRY_MISC_RE");
+    assert.match(ev.channel, SERVER_MISC_RE, "channel 必须匹配服务端 TELEMETRY_MISC_RE");
     if (ev.name === "install_failed" || ev.name === "update_failed") {
       assert.ok(failCodes.includes(ev.fail_code), "fail_code 必须在白名单内：" + ev.fail_code);
     }
@@ -365,12 +373,173 @@ test("隐私审计：对抗性 extra 字段（手机号/hostname/machine_fp/路
     for (const bad of ["phone", "password", "hostname", "machine_fp", "username", "device_id", "\\bip\\b", "path"]) {
       assert.ok(!new RegExp(bad).test(body), "payload 构造点里不得出现禁止字段：" + bad);
     }
-    for (const allowed of ["name", "at", "version", "os", "arch", "node", "fail_code"]) {
+    for (const allowed of ["name", "at", "version", "harness_version", "channel", "os", "arch", "node", "fail_code"]) {
       assert.ok(body.includes(allowed), "payload 构造点应只含白名单字段：" + allowed);
     }
   } finally { await env.restore(); relay.srv.close(); }
 });
 
+// ─────────────── 宿主 DSH 版本 + 更新通道（答得出"是不是 DSH 兼容性问题"） ───────────────
+//
+// 现场（2026-09）：注册 48 人只有 27 人成功，但"是不是兼容性问题"当天**答不出来** —— 遥测里的
+// `version` 是**插件自己**的版本，插件跑在哪个 DSH 上从来没上报过；这类数据**不能回填**，
+// 所以必须先埋上。下面锁死：
+//   ① 宿主版本是**运行时经验取到**的（按真实 dsh 启动形态：argv[1] → 上一级 package.json）；
+//   ② 未知/非法一律退化为空串（绝不猜、绝不抛、绝不改造原始值 —— 改写过的版本号比"未知"更糟）；
+//   ③ 通道 latest/beta 可分（否则预发用户与稳定用户混在一起，同样答不出问题）；
+//   ④ 既有事件名与既有字段一字不改。
+
+const INDEX_URL = new URL("../lib/index.js", import.meta.url).href;
+
+/** 造一个**真实布局**的假 DSH 宿主：<root>/package.json + <root>/lib/bin.js（argv[1] 会指向它）。 */
+async function fakeHarness(root, { name = "@deepseek-ai/dsh", version = "9.9.9-rc.1", entry = "" } = {}) {
+  const lib = path.join(root, "lib");
+  await mkdir(lib, { recursive: true });
+  await writeFile(path.join(root, "package.json"), JSON.stringify({ name, version, type: "module" }));
+  const entryFile = path.join(lib, "bin.js");
+  await writeFile(entryFile, entry);
+  return entryFile;
+}
+
+/** 子进程里按"真实 dsh 启动形态"跑一遍：argv[1] = 宿主 lib/bin.js，把一条事件打成 JSON。 */
+function payloadOfHost(entryFile, extraEnv = {}) {
+  return JSON.parse(execFileSync(process.execPath, [entryFile], {
+    encoding: "utf8", env: { ...process.env, ...extraEnv },
+  }).trim());
+}
+
+/** 假宿主入口的内容：像真 dsh 一样"主模块就是自己的 lib/bin.js"，插件在同一个进程里被装载。 */
+const PRINT_EVENT = `
+const m = await import(${JSON.stringify(INDEX_URL)});
+console.log(JSON.stringify(m.__telemetryInternals.eventOf("plugin_loaded")));
+`;
+
+test("宿主版本：运行时从主模块解析（argv[1] → 上一级 package.json）；未知一律空串且不抛", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "dsh-harness-"));
+  try {
+    const pkgDir = path.join(root, "pm", "node_modules", "@deepseek-ai", "dsh");
+    const entry = await fakeHarness(pkgDir, { version: "0.1.5-rc.2" });
+    assert.equal(TELEMETRY.harnessVersionFromEntry(entry), "0.1.5-rc.2", "应取到宿主 package.json 里的 version");
+    // 真实形态：`/opt/homebrew/bin/dsh` 是**软链** —— 不先 realpath 就会去读错的"上一级"
+    const link = path.join(root, "dsh");
+    try {
+      await symlink(entry, link);
+      assert.equal(TELEMETRY.harnessVersionFromEntry(link), "0.1.5-rc.2", "argv[1] 是软链时必须先落回真实文件");
+    } catch (e) {
+      if (e?.code !== "EPERM") throw e;   // Windows 无权限建软链 → 跳过该断言（macOS/Linux 覆盖真实形态）
+    }
+    // 未知的四条路：不存在 / 空 / 不是 DSH / 清单损坏
+    assert.equal(TELEMETRY.harnessVersionFromEntry(path.join(root, "nope", "bin.js")), "", "入口不存在 → 空串");
+    assert.equal(TELEMETRY.harnessVersionFromEntry(""), "", "空路径 → 空串");
+    assert.equal(TELEMETRY.harnessVersionFromEntry(undefined), "", "undefined → 空串（绝不抛）");
+    const other = await fakeHarness(path.join(root, "other"), { name: "not-dsh-at-all", version: "1.2.3" });
+    assert.equal(TELEMETRY.harnessVersionFromEntry(other), "", "非 DSH 启动（Electron/嵌入/别的脚本）绝不猜版本");
+    await writeFile(path.join(root, "other", "package.json"), "{ 这不是 JSON");
+    assert.equal(TELEMETRY.harnessVersionFromEntry(other), "", "清单损坏 → 空串，且不得抛");
+    // 本进程（测试进程 argv[1] = 本用例文件）→ 不可判定 = 空串；事件照常构造
+    assert.equal(TELEMETRY.harnessVersion(), "", "宿主不可判定时必须退化为空串（不是猜、不是抛）");
+    assert.equal(TELEMETRY.eventOf("plugin_loaded").harness_version, "", "取不到宿主版本也要照常构造事件（空串）");
+  } finally { await rm(root, { recursive: true, force: true }); }
+});
+
+test("payload：宿主版本与通道按真实启动形态进事件；beta 可区分；非法值发空串不改写", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "dsh-harness-e2e-"));
+  try {
+    const dshRoot = path.join(root, "node_modules", "@deepseek-ai", "dsh");
+    const entry = await fakeHarness(dshRoot, { version: "0.1.5-rc.2", entry: PRINT_EVENT });
+    const stable = payloadOfHost(entry);
+    assert.equal(stable.harness_version, "0.1.5-rc.2", "★宿主版本必须真的进 payload（这正是今天答不出来的那个数）");
+    // 通道由**本插件当前版本**推导：预发版 → beta，正式版 → latest（见 lib/index.js 的 updateChannel）。
+    // ⚠️ 不能硬编码 "latest" —— 那样每次切到 beta 发版、这条用例必红，而产品行为其实完全正确。
+    // 这里真正要守的不变量是「通道与当前版本自洽」（以及下面「beta 装机必须能与稳定版区分」）。
+    const pluginVersion = TELEMETRY.eventOf("plugin_loaded").version;
+    assert.equal(stable.channel, /-/.test(String(pluginVersion)) ? "beta" : "latest",
+      `通道必须与当前插件版本自洽（预发→beta / 正式→latest）；当前版本 ${pluginVersion}`);
+    assert.equal(stable.version, TELEMETRY.eventOf("plugin_loaded").version, "插件自身版本字段保持不变（两个 version 不是一回事）");
+    assert.equal(payloadOfHost(entry, { DSH_UPDATE_TAG: "beta" }).channel, "beta", "★beta 装机必须能与稳定版区分开");
+    assert.equal(payloadOfHost(entry, { DSH_UPDATE_TAG: "1.2.3-beta.1" }).channel, "1.2.3-beta.1", "显式指定版本号也要如实上报");
+    // 非 DSH 宿主：字段仍在（契约形状不变），值为空串 —— 降级而不是丢字段 / 报错
+    const plain = await fakeHarness(path.join(root, "plain"), { name: "some-other-cli", version: "9.9.9", entry: PRINT_EVENT });
+    assert.equal(payloadOfHost(plain).harness_version, "", "非 DSH 宿主 → 空串（不猜一个错的版本上去）");
+    // 服务端字符类不合法的版本串（semver 构建元数据 / 注入式取值）：发空串，绝不改造后发出去
+    const weird = await fakeHarness(path.join(root, "weird"), { version: "1.2.3+build/../../etc", entry: PRINT_EVENT });
+    const w = payloadOfHost(weird);
+    assert.equal(w.harness_version, "", "非法字符 → 空串（不改写、不截断、不拼接）");
+    assert.match(w.channel, SERVER_MISC_RE, "非法宿主版本不得把其他字段带坏");
+  } finally { await rm(root, { recursive: true, force: true }); }
+});
+
+test("清洗：只放行服务端字符类（[A-Za-z0-9._-] ≤32），其余发空串且绝不改造原始值", () => {
+  const t = TELEMETRY.harnessToken;
+  for (const ok of ["0.1.5-rc.2", "latest", "beta", "1.2.3", "2", "a".repeat(32)]) {
+    assert.equal(t(ok), ok, "合法值必须**原样**保留：" + ok);
+  }
+  for (const bad of ["1.2.3+build.7", "1.2.3/../etc", "mac.local hostname", "真.1.2.3", "a".repeat(33), " 1.2.3", "1.2.3 ", "", " ", "1.2.3\n"]) {
+    assert.equal(t(bad), "", "非法值必须发空串（不得截断/改写）：" + JSON.stringify(bad));
+  }
+  assert.equal(t(undefined), "", "undefined → 空串");
+  assert.equal(t(null), "", "null → 空串");
+  // 清洗后必须 100% 落在服务端字符类里（否则服务端会静默把它抹成空 —— 数据看起来像"没上报"）
+  for (const v of ["0.1.5-rc.2", "1.2.3+build", "a".repeat(33), "", "真", undefined]) {
+    assert.ok(SERVER_MISC_RE.test(t(v)), "清洗后的值必须 100% 落在服务端字符类内：" + JSON.stringify(v));
+  }
+});
+
+test("冻结契约：既有事件名与既有字段一字不改（本次只新增 harness_version / channel）", () => {
+  // 【本次改动】白名单**末尾追加** wechat_bound / wechat_unbound（微信机器人通道的绑定态跳变，
+  // 见 wechat-bind-telemetry.test.mjs）；既有 12 个名字一字未动、顺序未动，
+  // 服务端 TELEMETRY_EVENTS 同步追加同样两个名字。
+  //
+  // 这条断言的本意是「**既有**事件名/字段不许删改」，而不是"白名单永远不许变长"：
+  // 所以正确改法是**在预期集合里追加新名字**（下面那条 deepEqual 仍是全等比对，
+  // 任何删除 / 改名 / 重排 / 未声明的追加都会红），而不是把它弱化成"包含即可"。
+  // 为了把「既有项一个都不能少」这条不变量显式钉死（而不是只靠全等比对间接保证），
+  // 再单独比一次**前缀**：前 12 项必须与冻结前的历史名单逐字相同、顺序相同。
+  const FROZEN_EVENT_NAMES = [
+    "install_started", "install_failed", "runtime_ready", "bridge_started", "bridge_registered",
+    "tunnel_disconnected", "first_remote_ok", "plugin_loaded", "panel_opened", "harness_restart",
+    "update_started", "update_failed",
+  ];
+  assert.deepEqual(TELEMETRY.eventNames.slice(0, FROZEN_EVENT_NAMES.length), FROZEN_EVENT_NAMES,
+    "既有 12 个事件名一字不能改、不能删、不能重排（只允许在末尾追加新事件）");
+  assert.deepEqual(TELEMETRY.eventNames, [...FROZEN_EVENT_NAMES, "wechat_bound", "wechat_unbound"],
+    "事件名白名单只允许在末尾追加：本次追加微信通道的绑定/解绑，其余必须与服务端字面量冻结对齐");
+  const ev = TELEMETRY.eventOf("bridge_registered");
+  assert.deepEqual(Object.keys(ev), ["name", "at", "version", "harness_version", "channel", "os", "arch", "node"],
+    "字段白名单：既有的 7 个一个不少，只多 harness_version / channel");
+  assert.match(String(ev.version), /^\d+\.\d+\.\d+/, "version 仍是插件自身版本（非宿主版本）");
+  assert.equal(ev.os, process.platform);
+  assert.equal(ev.arch, process.arch);
+  assert.match(String(ev.node), /^\d+$/);
+  assert.ok(!("fail_code" in ev), "fail_code 仍只出现在 *_failed 事件上");
+  assert.equal(TELEMETRY.eventOf("user_login"), null, "白名单外事件名照旧不发");
+  // 通道与"一键更新"同源：面板看到的通道 = 上报的通道（两处口径必须是一处）
+  assert.equal(ev.channel, TELEMETRY.updateTag);
+});
+
+test("flush 路径：宿主版本/通道经磁盘队列读回后仍在，并随批次真实送达", async () => {
+  const relay = await startFakeRelay();
+  const env = await setup();
+  try {
+    await writeConfig(env.relayDir, relay.port);
+    // 模拟上一进程落盘的队列（含新字段）—— 重启前的事件不能丢归因
+    await writeFile(path.join(env.relayDir, ".telemetry-queue.json"), JSON.stringify({
+      v: 1,
+      events: [{
+        name: "harness_restart", at: Date.now() - 3000, version: "0.0.0-test",
+        harness_version: "0.1.5-rc.2", channel: "beta", os: process.platform, arch: process.arch, node: "22",
+      }],
+    }), { mode: 0o600 });
+    boot(env.relayDir);   // 装载即读回磁盘队列并补发
+    const sent = await waitFor(() => (relay.telemetry.length ? relay.telemetry : false));
+    assert.ok(sent, "遗留队列必须在下次装载时补发");
+    const ev = sent[0].body.events.find((e) => e.name === "harness_restart");
+    assert.equal(ev.harness_version, "0.1.5-rc.2", "磁盘读回后宿主版本不得丢");
+    assert.equal(ev.channel, "beta", "磁盘读回后通道不得丢");
+    assertContractRequest(sent[0], { eventNames: TELEMETRY.eventNames, failCodes: TELEMETRY.failCodes });
+  } finally { await env.restore(); relay.srv.close(); }
+});
+
 test("开关：DSH_REMOTE_TELEMETRY=0 → 零请求零文件（连 install_id 都不生成）", async () => {
   const relay = await startFakeRelay();
   const env = await setup({ runtime: false });
@@ -390,6 +559,10 @@ test("开关：DSH_REMOTE_TELEMETRY=0 → 零请求零文件（连 install_id
       assert.equal(TELEMETRY.installId(env.relayDir), null, "关闭后不得生成 install_id");
       assert.equal(TELEMETRY.queueOf(env.relayDir).length, 0);
       assert.equal(TELEMETRY.record(env.relayDir, "install_started"), false, "关闭后不得入队");
+      // 新增的宿主版本/通道字段不改变开关语义：关闭 = 连"带新字段的事件"也不入队、不出机器
+      assert.equal(TELEMETRY.record(env.relayDir, "plugin_loaded"), false, "关闭后带新字段的事件同样不得入队");
+      assert.equal(relay.count("/api/telemetry/events"), 0, "关闭后不得出现任何带 harness_version/channel 的请求");
+      assert.equal(relay.telemetry.some((r) => r.raw.includes("harness_version")), false, "关闭后不得有任何新字段上过网络");
     } finally { host.close(); routes.dispose(); }
   } finally { await env.restore(); relay.srv.close(); }
 });
@@ -602,6 +775,20 @@ test("面板可见性：关于卡片写明「匿名统计 + 关闭方式」，
   for (const line of ["不采集什么", "如何关闭", "hostname", "machine_fp", "IP", "DSH_REMOTE_TELEMETRY=0"]) {
     assert.ok(doc.includes(line), "docs/telemetry.md 必须覆盖：" + line);
   }
+  // 【本次改动】wechat_bound / wechat_unbound 已同步写进公开披露文档（docs/telemetry.md
+  // 的「事件名白名单」小节 + 微信通道绑定/解绑的语义与分母边界），因此这里**恢复成硬断言**：
+  // 每一个能出机器的事件名都必须在披露文档里逐条列出，没有豁免。
   for (const name of TELEMETRY.eventNames) assert.ok(doc.includes(name), "docs/telemetry.md 必须列出事件：" + name);
+  // 【本次改动】披露文档不只要列出名字，还必须写明这两条事件的**语义与分母边界** ——
+  // 否则看板上的"绑定数/存量"会被读成服务端的实时台账：
+  //   ① 它们是客户端上报的事件（不是服务端的实时存量）；
+  //   ② 首次观测到 bound:true 不算绑定事件（这条规则写错就会把历史存量每天虚报一遍）。
+  for (const line of [
+    "首次观测不算绑定",
+    "客户端上报的事件，不是服务端的实时存量",
+    "bot_id",
+  ]) {
+    assert.ok(doc.includes(line), "docs/telemetry.md 必须写明微信通道事件的口径边界：" + line);
+  }
   for (const code of TELEMETRY.failCodes) assert.ok(doc.includes(code), "docs/telemetry.md 必须列出失败码：" + code);
 });

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

@@ -82,6 +82,11 @@ async function plantInstallation(tempHome, opts = {}) {
     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",
+      // ⚠️ api_url 必须显式指向本地不可达端口 —— 缺了它会回落到 DEFAULT_API(生产中继),
+      // 而插件 boot 时会跑 reportInstallOnce → relayToken → bridgeSecretOf → fetch /api/public-config,
+      // 于是这个「卸载」用例会去打**生产**。测试期网络护栏会把它拦成 ENETUNREACH(所以不会真污染),
+      // 但那意味着用例是在「断网」分支上通过的,而不是它声称的场景。
+      api_url: "http://127.0.0.1:1",
     }));
     await writeFile(path.join(relayDir, "dsh-setup.mjs"), "// runtime stub");
     await writeFile(path.join(relayDir, "clients", "dsh-remote", "dsh-bridge.mjs"), "// bridge stub");