@mrrisega/dsh-remote 0.7.9 → 0.7.10-beta.10

package/clients/dsh-remote/test/agent-runtime.test.mjs

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+/**
+ * Agent Runtime 编排契约测试 —— 验证"默认关 / 门禁 / 让位 / 就绪 / 降级"五种出口。
+ *
+ * 这是挂载方唯一会直接调的入口，所以每条出口都要有明确、可断言的返回，
+ * 不能"抛错让上层猜"：
+ *
+ *   disabled → 不探测不占端口；cli-missing / version-* → 灰显原因；
+ *   existing-hooks → **只通知模式**（让位给本机策略）；bridge-error → 降级原因；
+ *   ready → 返回 launch.args + 临时 settings，并真的接上决策回调。
+ *
+ * 用法: node --test clients/dsh-remote/test/agent-runtime.test.mjs
+ */
+import assert from "node:assert/strict";
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { AGENT_STATUS, createAgentRuntime } from "../agent/index.mjs";
+
+/** ENOENT 风格的 fs 假实现。 */
+function makeFs(overrides = {}) {
+  const enoent = () => {
+    throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+  };
+  return {
+    existsSync: () => false,
+    statSync: () => enoent(),
+    readFileSync: () => enoent(),
+    realpathSync: (p) => p,
+    constants: {},
+    ...overrides
+  };
+}
+
+const okVersion = (text) => () => ({ status: 0, stdout: `${text} (Claude Code)\n`, stderr: "" });
+const noNpm = () => {
+  throw new Error("npm 不存在");
+};
+
+test("默认关：enabled 未给 → disabled，且**连探测都不做**（不占端口、不跑 CLI）", async () => {
+  let spawned = false;
+  const rt = createAgentRuntime({
+    env: {},
+    deps: {
+      spawnSync: () => {
+        spawned = true;
+        return { status: 0, stdout: "2.1.318", stderr: "" };
+      }
+    }
+  });
+  const r = await rt.start();
+  assert.equal(r.ok, false);
+  assert.equal(r.status, AGENT_STATUS.DISABLED);
+  assert.equal(r.mode, "notify-only");
+  assert.equal(spawned, false, "关闭状态不该探测（不浪费资源、不暴露能力）");
+  assert.equal(rt.status().status, AGENT_STATUS.DISABLED);
+});
+
+test("env 打开：DSH_AGENT_ENABLED=1 即启用（挂载方不必传参）", async () => {
+  const rt = createAgentRuntime({
+    env: { DSH_AGENT_ENABLED: "1", DSH_AGENT_CLAUDE_BIN: "/fake/claude" },
+    deps: { fs: makeFs(), spawnSync: okVersion("2.1.318"), execFileSync: noNpm }
+  });
+  const probed = rt.probe();
+  assert.equal(probed.ok, true, "显式 bin + 达标版本应探测通过");
+});
+
+test("probe()：只探测不占端口、不写盘（给入口灰显用）", () => {
+  const rt = createAgentRuntime({
+    env: { DSH_AGENT_CLAUDE_BIN: "/fake/claude" },
+    deps: { fs: makeFs(), spawnSync: okVersion("2.1.318"), execFileSync: noNpm }
+  });
+  const p = rt.probe();
+  assert.equal(p.ok, true);
+  assert.equal(p.status, "ok");
+  assert.equal(p.claude.path, "/fake/claude");
+  assert.equal(p.version.text, "2.1.318");
+  assert.equal(rt.status().status, AGENT_STATUS.DISABLED, "probe 不应改变运行状态");
+});
+
+test("probe() 结果缓存：面板重绘不反复 spawn CLI；force 可强测", () => {
+  let spawnCount = 0;
+  const rt = createAgentRuntime({
+    env: { DSH_AGENT_CLAUDE_BIN: "/fake/claude" },
+    deps: {
+      fs: makeFs(),
+      execFileSync: noNpm,
+      spawnSync: () => {
+        spawnCount += 1;
+        return { status: 0, stdout: "2.1.318 (Claude Code)\n", stderr: "" };
+      }
+    }
+  });
+  assert.equal(rt.probe().ok, true);
+  assert.equal(rt.probe().ok, true);
+  assert.equal(spawnCount, 1, "缓存期内第二次 probe 不应再 spawn（杀软会盯上常驻轮询）");
+  assert.equal(rt.probe({ force: true }).ok, true);
+  assert.equal(spawnCount, 2, "force 必须绕过缓存");
+});
+
+test("版本门禁：2.1.195 → version-unsupported，不启动桥接", async () => {
+  const rt = createAgentRuntime({
+    enabled: true,
+    env: { DSH_AGENT_CLAUDE_BIN: "/fake/claude" },
+    deps: { fs: makeFs(), spawnSync: okVersion("2.1.195"), execFileSync: noNpm }
+  });
+  const r = await rt.start();
+  assert.equal(r.ok, false);
+  assert.equal(r.status, AGENT_STATUS.VERSION_UNSUPPORTED);
+  assert.equal(r.mode, "notify-only");
+  assert.match(r.reason, /低于最低支持版本/);
+  assert.equal(r.port, undefined, "不可用时不得占端口");
+  assert.equal(rt.status().status, AGENT_STATUS.VERSION_UNSUPPORTED);
+});
+
+test("找不到 CLI → cli-missing（不抛错）", async () => {
+  const rt = createAgentRuntime({
+    enabled: true,
+    env: { PATH: "" },
+    deps: { fs: makeFs(), spawnSync: okVersion("2.1.318"), execFileSync: noNpm, npmRoot: "" }
+  });
+  const r = await rt.start();
+  assert.equal(r.ok, false);
+  assert.equal(r.status, AGENT_STATUS.CLI_MISSING);
+  assert.match(r.reason, /没有找到 Claude Code/);
+});
+
+test("既有审批钩子 → existing-hooks + notify-only（让位，不注入自己的钩子）", async () => {
+  const homeDir = "/home/u";
+  const fs = makeFs({
+    readFileSync: (p) => {
+      if (p === path.join(homeDir, ".claude", "settings.json")) {
+        return JSON.stringify({ hooks: { PermissionRequest: [{ hooks: [{ type: "command", command: "policy.sh" }] }] } });
+      }
+      throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+    }
+  });
+  const rt = createAgentRuntime({
+    enabled: true,
+    env: { DSH_AGENT_CLAUDE_BIN: "/fake/claude" },
+    deps: { fs, spawnSync: okVersion("2.1.318"), execFileSync: noNpm, homeDir }
+  });
+  const r = await rt.start();
+  assert.equal(r.ok, false);
+  assert.equal(r.status, AGENT_STATUS.EXISTING_HOOKS);
+  assert.equal(r.mode, "notify-only");
+  assert.match(r.reason, /让位/);
+});
+
+test("DSH_AGENT_NOTIFY_ONLY=1 → 强制只通知（企业策略/排障）", async () => {
+  const rt = createAgentRuntime({
+    env: {
+      DSH_AGENT_ENABLED: "1",
+      DSH_AGENT_NOTIFY_ONLY: "1",
+      DSH_AGENT_CLAUDE_BIN: "/fake/claude"
+    },
+    deps: { fs: makeFs(), spawnSync: okVersion("2.1.318"), execFileSync: noNpm }
+  });
+  const r = await rt.start();
+  assert.equal(r.ok, false);
+  assert.equal(r.status, AGENT_STATUS.EXISTING_HOOKS);
+  assert.equal(r.mode, "notify-only");
+  assert.match(r.reason, /强制只通知/);
+});
+
+test("就绪 → 返回 launch.args + 临时 settings，并真的接上决策回调", async () => {
+  const settingsDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "agent-rt-"));
+  const decided = [];
+  let settingsPath = "";
+  try {
+    const rt = createAgentRuntime({
+      enabled: true,
+      env: {
+        DSH_AGENT_CLAUDE_BIN: "/fake/claude",
+        DSH_AGENT_SETTINGS_DIR: settingsDir
+      },
+      decide: async (req) => {
+        decided.push(req);
+        return { decision: "deny", message: "手机端拒绝" };
+      },
+      deps: { fs: makeFs(), spawnSync: okVersion("2.1.318"), execFileSync: noNpm }
+    });
+
+    const r = await rt.start();
+    assert.equal(r.ok, true);
+    assert.equal(r.status, AGENT_STATUS.READY);
+    assert.equal(r.mode, "approval");
+    assert.ok(r.port > 0, "随机端口应已占用");
+    assert.equal(r.launch.args[0], "--permission-mode");
+    assert.equal(r.launch.args[1], "default");
+    assert.equal(r.launch.args[2], "--settings");
+    settingsPath = r.launch.args[3];
+    assert.equal(settingsPath, r.settingsPath);
+    assert.ok(fsSync.existsSync(settingsPath), "临时 settings 必须落盘");
+
+    // 从 settings 里取出带 token 的钩子 URL，模拟 Claude Code 发一次审批
+    const saved = JSON.parse(fsSync.readFileSync(settingsPath, "utf8"));
+    const hookUrl = saved.hooks.PermissionRequest[0].hooks[0].url;
+    const res = await fetch(hookUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        session_id: "s",
+        cwd: "/tmp/p",
+        permission_mode: "default",
+        hook_event_name: "PermissionRequest",
+        tool_name: "Bash",
+        tool_input: { command: "rm -rf build" }
+      })
+    });
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    assert.equal(body.hookSpecificOutput.decision.behavior, "deny");
+    assert.equal(body.hookSpecificOutput.decision.message, "手机端拒绝");
+    assert.equal(decided.length, 1, "决策回调应被调用一次");
+    assert.equal(decided[0].toolName, "Bash");
+    assert.equal(decided[0].detail, "rm -rf build", "detail 给决策方（手机）看");
+
+    await rt.stop();
+    assert.equal(fsSync.existsSync(settingsPath), false, "stop() 必须清理临时 settings");
+    assert.equal(rt.status().status, AGENT_STATUS.DISABLED, "停止后回到未启用状态");
+    await rt.stop(); // 幂等
+  } finally {
+    fsSync.rmSync(settingsDir, { recursive: true, force: true });
+  }
+});
+
+test("没有决策来源 → 立即拒绝（fail-closed，不等 90s）", async () => {
+  const settingsDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "agent-rt2-"));
+  try {
+    const rt = createAgentRuntime({
+      enabled: true,
+      env: { DSH_AGENT_CLAUDE_BIN: "/fake/claude", DSH_AGENT_SETTINGS_DIR: settingsDir },
+      deps: { fs: makeFs(), spawnSync: okVersion("2.1.318"), execFileSync: noNpm }
+    });
+    const r = await rt.start();
+    assert.equal(r.ok, true);
+    const saved = JSON.parse(fsSync.readFileSync(r.settingsPath, "utf8"));
+    const res = await fetch(saved.hooks.PermissionRequest[0].hooks[0].url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        hook_event_name: "PermissionRequest",
+        tool_name: "Bash",
+        tool_input: { command: "echo hi" }
+      })
+    });
+    const body = await res.json();
+    assert.equal(body.hookSpecificOutput.decision.behavior, "deny");
+    assert.match(body.hookSpecificOutput.decision.message, /未接入决策来源/);
+    await rt.stop();
+  } finally {
+    fsSync.rmSync(settingsDir, { recursive: true, force: true });
+  }
+});
+
+test("桥接启动失败（临时目录不可写）→ bridge-error + notify-only，不抛错", async () => {
+  const rt = createAgentRuntime({
+    enabled: true,
+    env: { DSH_AGENT_CLAUDE_BIN: "/fake/claude" },
+    deps: {
+      fs: makeFs(),
+      spawnSync: okVersion("2.1.318"),
+      execFileSync: noNpm,
+      bridgeFs: {
+        mkdtempSync: () => {
+          throw Object.assign(new Error("EACCES: permission denied"), { code: "EACCES" });
+        },
+        writeFileSync: () => {},
+        rmSync: () => {}
+      }
+    }
+  });
+  const r = await rt.start();
+  assert.equal(r.ok, false);
+  assert.equal(r.status, AGENT_STATUS.BRIDGE_ERROR);
+  assert.equal(r.mode, "notify-only");
+  assert.match(r.reason, /审批桥接启动失败/);
+  assert.equal(rt.status().status, AGENT_STATUS.BRIDGE_ERROR);
+});

package/clients/dsh-remote/test/agent-version.test.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * 版本门禁契约测试。
+ *
+ * 背景（M2 第 1 周实测，报告 §2.2）：同一条 `PermissionRequest` 钩子注入，
+ * **2.1.318 生效、2.1.195 完全不触发**。旧版本上动作仍会被 Claude Code 自己拒绝，
+ * 但我们的手机端**永远收不到审批** —— 静默失败比明确不可用危险得多，所以门禁必须硬。
+ *
+ * 这里守四件事：
+ *   ① 解析 `claude --version` 的真实输出形态（`2.1.195 (Claude Code)` 等）；
+ *   ② 比较语义（含预发布 < 正式版）；
+ *   ③ 阈值可被 env 覆盖，但**写错必须回落保守默认**（不能因为配置错就放行）；
+ *   ④ 版本低于阈值 → `ok:false` + 明确 status；等于阈值 → 放行（边界）。
+ *
+ * 用法: node --test clients/dsh-remote/test/agent-version.test.mjs
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  DEFAULT_MIN_CLAUDE_VERSION,
+  MIN_VERSION_ENV,
+  checkVersionGate,
+  compareVersions,
+  formatVersion,
+  parseClaudeVersion,
+  resolveMinVersion
+} from "../agent/version.mjs";
+
+test("解析：本机实测输出 `2.1.195 (Claude Code)`", () => {
+  const v = parseClaudeVersion("2.1.195 (Claude Code)\n");
+  assert.deepEqual(
+    { major: v.major, minor: v.minor, patch: v.patch, prerelease: v.prerelease },
+    { major: 2, minor: 1, patch: 195, prerelease: "" }
+  );
+});
+
+test("解析：兼容 `claude 2.1.318` / 纯版本号 / 预发布", () => {
+  assert.equal(parseClaudeVersion("claude 2.1.318").patch, 318);
+  assert.equal(parseClaudeVersion("2.1.318").minor, 1);
+  const pre = parseClaudeVersion("2.1.318-beta.2 (Claude Code)");
+  assert.equal(pre.prerelease, "beta.2");
+});
+
+test("解析：认不出就返回 null（不抛错，交给门禁保守处理）", () => {
+  for (const bad of ["", "   ", "not-a-version", "Claude Code", undefined, null]) {
+    assert.equal(parseClaudeVersion(bad), null, `应返回 null: ${String(bad)}`);
+  }
+});
+
+test("比较：数字段优先，预发布 < 同号正式版", () => {
+  const a = parseClaudeVersion("2.1.195");
+  const b = parseClaudeVersion("2.1.318");
+  const c = parseClaudeVersion("2.2.0");
+  assert.equal(compareVersions(a, b), -1);
+  assert.equal(compareVersions(b, a), 1);
+  assert.equal(compareVersions(a, a), 0);
+  assert.equal(compareVersions(b, c), -1, "minor 更大即更新");
+  const pre = parseClaudeVersion("2.1.318-beta.1");
+  const rel = parseClaudeVersion("2.1.318");
+  assert.equal(compareVersions(pre, rel), -1);
+  assert.equal(compareVersions(rel, pre), 1);
+});
+
+test("格式化：预发布保留后缀", () => {
+  assert.equal(formatVersion(parseClaudeVersion("2.1.318")), "2.1.318");
+  assert.equal(formatVersion(parseClaudeVersion("2.1.318-rc.1")), "2.1.318-rc.1");
+  assert.equal(formatVersion(null), "");
+});
+
+test("阈值：默认 2.1.318（实测唯一确认可用的版本）", () => {
+  const r = resolveMinVersion({});
+  assert.equal(r.source, "default");
+  assert.equal(r.minText, DEFAULT_MIN_CLAUDE_VERSION);
+  assert.equal(DEFAULT_MIN_CLAUDE_VERSION, "2.1.318");
+});
+
+test("阈值：env 可覆盖（版本二分/灰度用）", () => {
+  const r = resolveMinVersion({ [MIN_VERSION_ENV]: "2.1.250" });
+  assert.equal(r.source, "env");
+  assert.equal(r.minText, "2.1.250");
+  assert.equal(r.warning, undefined);
+});
+
+test("阈值：env 写错必须回落默认 + 告警（不能因为配置错就放行）", () => {
+  const r = resolveMinVersion({ [MIN_VERSION_ENV]: "latest" });
+  assert.equal(r.source, "default");
+  assert.equal(r.minText, DEFAULT_MIN_CLAUDE_VERSION);
+  assert.match(r.warning, /不是合法版本号/);
+});
+
+test("门禁：低于阈值 → version-unsupported（带 required/actual）", () => {
+  const r = checkVersionGate({
+    version: parseClaudeVersion("2.1.195"),
+    min: parseClaudeVersion("2.1.318"),
+    minText: "2.1.318",
+    versionText: "2.1.195"
+  });
+  assert.equal(r.ok, false);
+  assert.equal(r.status, "version-unsupported");
+  assert.equal(r.required, "2.1.318");
+  assert.equal(r.actual, "2.1.195");
+  assert.match(r.reason, /低于最低支持版本/);
+});
+
+test("门禁：等于阈值放行（边界不能把达标版本挡掉）", () => {
+  const r = checkVersionGate({
+    version: parseClaudeVersion("2.1.318"),
+    min: parseClaudeVersion("2.1.318"),
+    minText: "2.1.318",
+    versionText: "2.1.318"
+  });
+  assert.equal(r.ok, true);
+  assert.equal(r.status, "ok");
+});
+
+test("门禁：拿不到版本 → version-unknown（保守不放行）", () => {
+  const r = checkVersionGate({ version: null, min: parseClaudeVersion("2.1.318"), minText: "2.1.318" });
+  assert.equal(r.ok, false);
+  assert.equal(r.status, "version-unknown");
+  assert.match(r.reason, /无法解析/);
+});

package/clients/dsh-remote/test/approval-coordinator.test.mjs

@@ -0,0 +1,192 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createApprovalCoordinator, DENY_MESSAGES, MAX_PENDING_APPROVALS } from "../approval-coordinator.mjs";
+
+/** 可控假时钟：手动 flush 到点的定时器。 */
+function makeClock() {
+  let seq = 0;
+  const timers = new Map();
+  return {
+    setTimeoutImpl(fn, ms) {
+      const id = ++seq;
+      timers.set(id, { fn, ms, at: ms });
+      return id;
+    },
+    clearTimeoutImpl(id) { timers.delete(id); },
+    /** 触发所有到点的定时器（简单起见：全部触发）。 */
+    fireAll() {
+      const list = [...timers.entries()].slice();
+      for (const [id, t] of list) { timers.delete(id); t.fn(); }
+      return list.length;
+    },
+    count() { return timers.size; }
+  };
+}
+
+const flush = () => new Promise((r) => setImmediate(r));
+
+test("① 手机点允许 → ask() 返回 allow（只允许一次，由调用方映射）", async () => {
+  const clock = makeClock();
+  const reports = [];
+  const c = createApprovalCoordinator({
+    report: (p) => { reports.push(p); },
+    ...clock
+  });
+  const p = c.ask({ requestId: "r1", toolName: "Bash", detail: "npm run deploy" });
+  assert.deepEqual(c._pendingIds(), ["r1"]);
+  assert.equal(reports.length, 1);
+  assert.equal(reports[0].requestId, "r1");
+  assert.equal(reports[0].summary, "npm run deploy");
+  assert.equal(c.resolve("r1", "allow"), true);
+  assert.deepEqual(await p, { decision: "allow", message: undefined });
+  assert.equal(c.status().allowed, 1);
+  assert.equal(clock.count(), 0, "settle 后必须清掉定时器");
+});
+
+test("② 手机点拒绝 → deny，且带拒绝说明", async () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({ report: () => true, ...clock });
+  const p = c.ask({ requestId: "r2", toolName: "Write" });
+  assert.equal(c.resolve("r2", "deny"), true);
+  const r = await p;
+  assert.equal(r.decision, "deny");
+  assert.equal(c.status().denied, 1);
+});
+
+test("③ TTL 到点 → 必须 deny（fail-closed：没人拍板 ≠ 同意）", async () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({ report: () => true, ttlMs: 90_000, ...clock });
+  const p = c.ask({ requestId: "r3", toolName: "Bash", detail: "rm -rf build" });
+  assert.equal(clock.fireAll(), 1);
+  const r = await p;
+  assert.equal(r.decision, "deny");
+  assert.equal(r.message, DENY_MESSAGES.timeout);
+  assert.equal(c.status().expired, 1);
+});
+
+test("④ 重复 resolve 幂等返回 false（不覆盖第一次决定）", async () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({ report: () => true, ...clock });
+  const p = c.ask({ requestId: "r4" });
+  assert.equal(c.resolve("r4", "allow"), true);
+  assert.equal(c.resolve("r4", "deny"), false);
+  assert.equal((await p).decision, "allow");
+});
+
+test("⑤ 不认识的 requestId → resolve 返回 false（交给 DSH 那条路处理）", () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({ report: () => true, ...clock });
+  assert.equal(c.resolve("not-mine", "allow"), false);
+});
+
+test("⑥ 并发上限：超过上限直接拒绝，不让第 9 条挂着", async () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({ report: () => true, ...clock });
+  const ps = [];
+  for (let i = 0; i < MAX_PENDING_APPROVALS; i++) ps.push(c.ask({ requestId: "ok-" + i }));
+  const over = await c.ask({ requestId: "over-1" });
+  assert.equal(over.decision, "deny");
+  assert.equal(over.message, DENY_MESSAGES.overflow);
+  assert.equal(c.status().overflow, 1);
+  // 清理：全部决议掉，避免悬挂
+  for (let i = 0; i < MAX_PENDING_APPROVALS; i++) c.resolve("ok-" + i, "deny");
+  await Promise.all(ps);
+});
+
+test("⑦ 同一请求重复 ask（钩子重试）复用同一个 Promise，且只上报一次", async () => {
+  const clock = makeClock();
+  let reports = 0;
+  const c = createApprovalCoordinator({ report: () => { reports += 1; }, ...clock });
+  const p1 = c.ask({ requestId: "dup" });
+  const p2 = c.ask({ requestId: "dup" });
+  assert.equal(p1, p2);
+  assert.equal(reports, 1);
+  c.resolve("dup", "allow");
+  assert.deepEqual(await p1, { decision: "allow", message: undefined });
+});
+
+test("⑧ stop() 把全部未决审批结算为拒绝（绝不留悬挂 Promise）", async () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({ report: () => true, ...clock });
+  const p1 = c.ask({ requestId: "s1" });
+  const p2 = c.ask({ requestId: "s2" });
+  const n = c.stop();
+  assert.equal(n, 2);
+  assert.equal((await p1).decision, "deny");
+  assert.equal((await p2).decision, "deny");
+  assert.equal(c._pendingIds().length, 0);
+  // stop 之后新请求立即拒绝，不再挂着
+  const r = await c.ask({ requestId: "s3" });
+  assert.equal(r.decision, "deny");
+  assert.equal(r.message, DENY_MESSAGES.stopped);
+});
+
+test("⑨ 上报抛错不影响超时兜底（不会挂死钩子）", async () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({
+    report: () => { throw new Error("network down"); },
+    ...clock
+  });
+  const p = c.ask({ requestId: "r9" });
+  assert.equal(clock.fireAll(), 1);
+  const r = await p;
+  assert.equal(r.decision, "deny");
+});
+
+test("⑩ 没有上报通道时也能工作（到点拒绝），并告警一次", async () => {
+  const clock = makeClock();
+  const warnings = [];
+  const c = createApprovalCoordinator({
+    log: (lvl, msg) => { if (lvl === "warn") warnings.push(msg); },
+    ...clock
+  });
+  const p = c.ask({ requestId: "r10" });
+  clock.fireAll();
+  assert.equal((await p).decision, "deny");
+  assert.ok(warnings.some((w) => /没有上报通道/.test(w)));
+});
+
+test("⑪ 日志不含命令原文（隐私）；只含 requestId/toolName/结论", async () => {
+  const clock = makeClock();
+  const logs = [];
+  const c = createApprovalCoordinator({
+    report: () => true,
+    log: (lvl, msg) => logs.push(msg),
+    ...clock
+  });
+  const p = c.ask({ requestId: "r11", toolName: "Bash", detail: "rm -rf /important" });
+  c.resolve("r11", "allow");
+  await p;
+  const all = logs.join("\n");
+  assert.ok(!all.includes("rm -rf /important"), "日志绝不能出现命令原文");
+  assert.match(all, /r11/);
+});
+
+test("⑫ 缺 requestId 的请求直接拒绝（不挂起）", async () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({ report: () => true, ...clock });
+  const r = await c.ask({ toolName: "Bash" });
+  assert.equal(r.decision, "deny");
+  assert.equal(c._pendingIds().length, 0);
+});
+
+test("⑬ status() 字段齐全（面板/诊断用）", () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({ report: () => true, ...clock });
+  const st = c.status();
+  for (const k of ["asked", "allowed", "denied", "expired", "overflow", "pending", "ttlMs", "maxPending"]) {
+    assert.ok(k in st, "status 缺字段 " + k);
+  }
+  assert.equal(st.ttlMs, 90_000);
+});
+
+test("⑭ resolve 后立刻 await 能拿到结果（微任务级，不需要额外 tick）", async () => {
+  const clock = makeClock();
+  const c = createApprovalCoordinator({ report: () => true, ...clock });
+  const p = c.ask({ requestId: "fast" });
+  c.resolve("fast", "allow");
+  const r = await p;
+  assert.equal(r.decision, "allow");
+  await flush();
+});

package/clients/dsh-remote/test/bridge-e2ee-reject-observable.test.mjs

@@ -0,0 +1,90 @@
+// E2EE 死会话拒绝的**可观测字段**回归 · bridge 侧（0.7.10 / W1-T3）。
+//
+// 背景（2026-10 生产复盘）：手机端与电脑之间的 WS 升级被拒里 **71.8%** 是
+// `e2ee_session_locked`（死会话），涉 163 用户；单个设备一天能撞 8997 次。
+// 0.7.3+ 已闭环（行为回归见 e2ee-shim-selfheal / mobile-adapter-resume 两个用例）：
+//   · 手机侧：清内存会话 + 清交接单 + 每标签页最多一次受控 reload，徽标写「加密会话已失效」；
+//   · bridge 侧：拒绝时回 `retryable:true, action:"rehandshake"`，手机可自动重握手。
+//
+// 缺的那一半是「闭环之后还剩多少」：这个比例以前只在 nginx/router 侧算得出来，
+// 客户端自己的支持包答不出。本文件锁死新增的可观测记账：
+//   ① 拒绝次数进 `.dsh-bridge-state.json`（节流 ≥10s，不加定时器、不额外写盘）；
+//   ② 协议行为一个字节都不变（拒绝帧仍带 retryable/action）。
+// 插件侧「复制诊断信息」带出这一行的用例见 packages/dsh-remote-web/test/e2ee-reject-diag.test.mjs。
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+const tmpDir = await mkdtemp(path.join(os.tmpdir(), "dsh-e2ee-rej-"));
+// 环境必须在 import dsh-bridge 之前定好（模块级常量在 import 时求值）
+process.env.DSH_BRIDGE_CONFIG = path.join(tmpDir, ".dsh-config.json");
+process.env.DSH_BRIDGE_UPSTREAM = "http://127.0.0.1:1"; // 本用例只走拒绝分支，不连上游
+process.env.DSH_BRIDGE_TUNNEL_URL = "ws://127.0.0.1:1";
+const bridge = await import("../dsh-bridge.mjs");
+const e2eeMod = await import("../e2ee-client.mjs");
+const STATE_FILE = path.join(tmpDir, ".dsh-bridge-state.json");
+
+test.after(async () => {
+  try { bridge.__setE2eeForTest(new e2eeMod.E2eeService({ enabled: false })); } catch { /* 忽略 */ }
+  try { await rm(tmpDir, { recursive: true, force: true }); } catch { /* 忽略 */ }
+});
+
+function spy() {
+  const frames = [];
+  return { frames, send: (obj) => { frames.push(obj); return true; } };
+}
+const readState = async () => {
+  try { return JSON.parse(await readFile(STATE_FILE, "utf8")) || {}; } catch { return {}; }
+};
+
+test("★ e2ee 会话失效拒绝：协议不变（retryable+rehandshake）且记进状态文件", async () => {
+  bridge.__setE2eeForTest(new e2eeMod.E2eeService({
+    enabled: true, mk: Buffer.alloc(32, 7), profile: "pbkdf2-sha256-600k", salt: "salt-abc", epoch: 0
+  }));
+  try {
+    const before = bridge.__e2eeRejectStatsForTest().locked;
+    const { frames, send } = spy();
+    const sessId = e2eeMod.newSessId();
+    await bridge.handleWsOpen(send, {
+      id: "e2ee-locked",
+      type: "ws-open",
+      path: `/ws-echo?e2ee=${sessId}&w=0123456789abcdef`,
+      headers: {}
+    });
+    assert.equal(frames.length, 1);
+    assert.equal(frames[0].ok, false);
+    assert.equal(frames[0].code, 1008);
+    assert.equal(frames[0].retryable, true, "★ 必须告诉手机这是可自动重试的（0.7.3+ 闭环的一半）");
+    assert.equal(frames[0].action, "rehandshake", "★ 让手机自动重握手，而不是弹「请重新解锁」");
+    assert.match(String(frames[0].reason || ""), /e2ee_session_locked/);
+
+    assert.equal(bridge.__e2eeRejectStatsForTest().locked, before + 1, "拒绝必须记账（可观测字段的来源）");
+    // 首次拒绝立即落盘（之后 10s 内节流合并）—— 支持包里不必等心跳就能看到
+    const state = await readState();
+    assert.equal(state.e2ee_ws_reject_locked, before + 1, "状态文件应带 e2ee_ws_reject_locked");
+    assert.ok(Number(state.e2ee_ws_reject_at) > 0, "应有最近一次拒绝时间（判断是否还在持续撞）");
+  } finally {
+    bridge.__setE2eeForTest(new e2eeMod.E2eeService({ enabled: false }));
+  }
+});
+
+test("★ e2ee 未启用（明文回退）的拒绝单独计数，不与死会话混在一起", async () => {
+  bridge.__setE2eeForTest(new e2eeMod.E2eeService({ enabled: false }));
+  try {
+    const before = bridge.__e2eeRejectStatsForTest().disabled;
+    const { frames, send } = spy();
+    await bridge.handleWsOpen(send, {
+      id: "e2ee-off",
+      type: "ws-open",
+      path: `/ws-echo?e2ee=${e2eeMod.newSessId()}&w=0123456789abcdef`,
+      headers: {}
+    });
+    assert.equal(frames[0].ok, false);
+    assert.match(String(frames[0].reason || ""), /e2ee_disabled/);
+    assert.equal(bridge.__e2eeRejectStatsForTest().disabled, before + 1, "e2ee_disabled 必须单独计数");
+  } finally {
+    bridge.__setE2eeForTest(new e2eeMod.E2eeService({ enabled: false }));
+  }
+});