@mrrisega/dsh-remote 0.6.4-beta.2 → 0.6.4-beta.4

package/packages/dsh-remote-web/test/auto-restart.test.mjs

@@ -0,0 +1,297 @@
+// 【自动化】首次安装/更新后「自动重启 DeepSeek harness」的安全回归（浏览器半，0.6.4）。
+//
+// 目标：用户装完不需要点任何按钮 —— 面板发现「待重启」后自己倒计时重启，重启后自动恢复页面
+// （复用既有 restartHarness + waitHarnessBack：轮询到 harness 回来即自动刷新）。
+// 但「自动重启进程」是危险动作，本用例锁死四条安全阀：
+//   ① 只在面板可见时计时（用户没在看就不动）；
+//   ② 15 秒倒计时内可一键取消，取消标记按本次事件（restart.at）持久化，同一事件不再自动重启；
+//   ③ 面板上有其他操作在跑（busy≠""）时暂停计时，不打断用户正在做的事；
+//   ④ 只重启一次（重启后 pending 结清即停）；无待重启时一个请求都不发。
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import vm from "node:vm";
+
+const SOURCE = readFileSync(new URL("../lib/client.js", import.meta.url), "utf8");
+
+function walk(node, visit) {
+  if (node == null) return;
+  if (Array.isArray(node)) { for (const item of node) walk(item, visit); return; }
+  if (typeof node !== "object") return;
+  visit(node);
+  for (const child of node.children || []) walk(child, visit);
+}
+function find(tree, predicate) {
+  let match;
+  walk(tree, (node) => { if (!match && predicate(node)) match = node; });
+  return match;
+}
+function textHas(tree, substr) {
+  return !!find(tree, (node) => (node.children || []).some((c) => typeof c === "string" && c.includes(substr)));
+}
+function nodeWithText(tree, substr) {
+  return find(tree, (node) => typeof node.props?.onClick === "function" && (node.children || []).some((c) => typeof c === "string" && c.includes(substr)));
+}
+
+const flush = () => new Promise((resolve) => setImmediate(resolve));
+
+const NOT_LOGGED = { ok: true, config: { phone: "", hasPhone: false, mode: "saas", deviceId: "" }, service: { running: false }, remoteUrl: "https://app.test/" };
+const LOGGED = { ok: true, config: { phone: "138****0000", hasPhone: true, mode: "saas", deviceId: "dev-x" }, service: { running: true }, remoteUrl: "https://app.test/" };
+const KEY_URL = "https://app.test/a/K1";
+const SESSIONS = [{ id: "ms_1", label: "iPhone 15", os: "iOS", browser: "Safari", created_at: 1700000000000, last_seen_at: 1700000600000, revoked_at: null }];
+function statusWithRestart(pending, at) {
+  return Object.assign({}, LOGGED, { restart: { pending: !!pending, kind: "first-install", reason: "首次安装需要重启 DeepSeek harness", at: at || 0 } });
+}
+
+function loadPlugin(opts = {}) {
+  let moduleFactory;
+  const registered = new Map();
+  const injects = new Map();
+  const requests = [];
+  const clipboard = [];
+  const states = [];
+  let hook = 0;
+  let effectCursor = 0;
+  let effectSlots = [];
+  let pending = [];
+  const listeners = new Map();
+
+  let clock = 0;
+  let timerSeq = 1;
+  const timers = new Map();
+  const job = (fn) => { try { fn(); } catch (e) { /* 内部错误由断言暴露 */ } };
+  const fakeSetTimeout = (fn, ms) => { const id = timerSeq++; timers.set(id, { at: clock + (Number(ms) || 0), fn, every: 0 }); return id; };
+  const fakeSetInterval = (fn, ms) => { const id = timerSeq++; const every = Math.max(1, Number(ms) || 1); timers.set(id, { at: clock + every, fn, every }); return id; };
+  const fakeClear = (id) => { timers.delete(id); };
+  async function advance(ms) {
+    const target = clock + ms;
+    for (let guard = 0; guard < 2000; guard++) {
+      let due = null;
+      for (const [id, t] of timers) if (t.at <= target && (!due || t.at < due[1].at)) due = [id, t];
+      if (!due) break;
+      const [id, t] = due;
+      clock = t.at;
+      if (t.every) t.at = clock + t.every; else timers.delete(id);
+      job(t.fn);
+      await flush();
+    }
+    clock = target;
+    await flush(); await flush();
+  }
+
+  const react = {
+    createElement(type, props, ...children) { return { type, props: props || {}, children }; },
+    useState(initial) {
+      const index = hook++;
+      if (!(index in states)) states[index] = typeof initial === "function" ? initial() : initial;
+      return [states[index], (value) => { states[index] = typeof value === "function" ? value(states[index]) : value; }];
+    },
+    useEffect(fn, deps) {
+      const index = effectCursor++;
+      const prev = effectSlots[index];
+      const changed = !prev || !deps || deps.length !== prev.deps.length || deps.some((d, i) => !Object.is(d, prev.deps[i]));
+      if (changed) pending.push({ index, fn, deps: deps ? [...deps] : deps });
+    },
+    useCallback(fn) { return fn; },
+    useSyncExternalStore(_subscribe, getSnapshot) { return getSnapshot(); },
+  };
+
+  const response = (status, body) => Promise.resolve({
+    ok: status >= 200 && status < 300,
+    status,
+    text: async () => JSON.stringify(body),
+  });
+
+  let statusBody = opts.status || NOT_LOGGED;
+  let restartCalls = 0;
+  const connBody = null;
+  let connCalls = 0;
+  let keyCalls = 0;
+  let sessCalls = 0;
+
+  const makeEl = () => ({
+    tag: "div", children: [], style: {}, className: "", attributes: {}, textContent: "",
+    setAttribute(k, v) { this.attributes[k] = v; },
+    getAttribute(k) { return this.attributes[k] ?? null; },
+    appendChild(c) { this.children.push(c); },
+    addEventListener(type, fn) { if (!listeners.has(type)) listeners.set(type, []); listeners.get(type).push(fn); },
+    removeEventListener(type, fn) {
+      const list = listeners.get(type) || [];
+      const i = list.indexOf(fn);
+      if (i >= 0) list.splice(i, 1);
+    },
+  });
+  const doc = {
+    hidden: false,
+    createElement: makeEl,
+    head: makeEl(),
+    body: makeEl(),
+    querySelector() { return null; },
+    querySelectorAll() { return []; },
+    getElementById() { return null; },
+    addEventListener(type, fn) { if (!listeners.has(type)) listeners.set(type, []); listeners.get(type).push(fn); },
+    removeEventListener(type, fn) {
+      const list = listeners.get(type) || [];
+      const i = list.indexOf(fn);
+      if (i >= 0) list.splice(i, 1);
+    },
+  };
+  class MutationObserverMock { constructor() {} observe() {} disconnect() {} }
+  const localStorage = {
+    // 支持预置存储(验证「取消标记跨刷新生效」:getItem 走真实读取路径)
+    _s: new Map(Object.entries(opts.localStorage || {})),
+    getItem(k) { return this._s.has(k) ? this._s.get(k) : null; },
+    setItem(k, v) { this._s.set(k, String(v)); },
+    removeItem(k) { this._s.delete(k); },
+  };
+
+  const sandbox = {
+    window: { __ModuleLoader__: { load(spec) { moduleFactory = spec.factory; } }, open() { return null; } },
+    document: doc,
+    localStorage,
+    MutationObserver: MutationObserverMock,
+    navigator: { clipboard: { writeText: async (t) => { clipboard.push(String(t)); } } },
+    setTimeout: fakeSetTimeout,
+    clearTimeout: fakeClear,
+    setInterval: fakeSetInterval,
+    clearInterval: fakeClear,
+    fetch(path, options = {}) {
+      requests.push({ path, method: options.method || "GET", body: options.body ? JSON.parse(options.body) : null });
+      if (path === "/dsh-remote/status") return response(200, statusBody);
+      if (path === "/dsh-remote/bridge-status") { connCalls += 1; return response(200, { ok: true }); }
+      if (path === "/dsh-remote/harness/restart") {
+        restartCalls += 1;
+        // 重启后 harness 会带着新的 bootId 回来:模拟「待重启已结清」
+        statusBody = Object.assign({}, statusBody, { restart: { pending: false, kind: "", reason: "", at: statusBody.restart?.at || 0 } });
+        return response(200, Object.assign({}, statusBody, { ok: true, mode: "launchd" }));
+      }
+      if (path === "/dsh-remote/access-key") {
+        keyCalls += 1;
+        return response(200, { ok: true, url: KEY_URL, key: "K1", expires_at: Date.now() + 1800000, ttl_ms: 1800000, qr_data_url: "data:image/png;base64,AAAA" });
+      }
+      if (path === "/dsh-remote/mobile-sessions") {
+        sessCalls += 1;
+        return response(200, { ok: true, sessions: opts.sessions || SESSIONS });
+      }
+      if (path === "/dsh-remote/captcha") return response(200, { captcha_id: "cap-1", svg: "<svg></svg>" });
+      if (path === "/dsh-remote/register") return response(201, { ok: true, token: "jwt-reg" });
+      if (path === "/dsh-remote/config") return response(200, statusBody);
+      if (path === "/dsh-remote/account") return response(200, { ok: true, account: { phone: "138****0000", plan: "free", plan_source: "plan" } });
+      if (path === "/dsh-remote/quota") return response(200, { ok: true, quota: null });
+      if (path === "/dsh-remote/remote-url") return response(200, { ok: true, remoteUrl: "https://app.test/", publicConfig: {} });
+      return response(200, { ok: true });
+    },
+    Set, Symbol, Date, JSON, Math, Number, String, Object, Array, console,
+  };
+
+  vm.runInNewContext(SOURCE, sandbox);
+  const plugin = moduleFactory((name) => {
+    assert.equal(name, "react");
+    return react;
+  });
+  plugin.apply({
+    slots: {
+      inject(name, cb) { injects.set(name, cb); cb(); },
+      register(meta, component) { registered.set(meta.id, component); return () => {}; },
+    },
+  });
+
+  return {
+    requests, states, clipboard,
+    counts() { return { connCalls, keyCalls, sessCalls, restartCalls }; },
+    /** 改写状态响应(模拟 pending 被结清/用户取消后再次出现等)。 */
+    setStatus(body) { statusBody = body; },
+    /** 渲染一轮并执行本轮需要运行的 effects（含 cleanup）。 */
+    render() {
+      hook = 0; effectCursor = 0; pending = [];
+      const tree = registered.get("dsh-remote")({ close() {} });
+      const todos = pending; pending = [];
+      for (const t of todos) {
+        const prev = effectSlots[t.index];
+        if (prev && typeof prev.cleanup === "function") job(prev.cleanup);
+        const cleanup = t.fn();
+        effectSlots[t.index] = { deps: t.deps, cleanup: typeof cleanup === "function" ? cleanup : null };
+      }
+      return tree;
+    },
+    async settle(times = 3) {
+      for (let i = 0; i < times; i++) { this.render(); await flush(); await flush(); }
+      return this.render();
+    },
+    advance,
+    /** 登录成功（面板读到登录态）→ 登录态 effect 重跑，自动开始推进连接。 */
+    async login() {
+      statusBody = LOGGED;
+      await advance(30_000); // 等 30s 状态轮询把登录态带进面板
+      return this.settle();
+    },
+    /** 连接阶段推进（node 半短轮询的应答变化）。 */
+    setConnect(phase, extra) { connBody = connectPayload(phase, extra); },
+    setConnectRaw(body) { connBody = body; },
+    hide() { doc.hidden = true; },
+    show() { doc.hidden = false; for (const fn of listeners.get("visibilitychange") || []) job(fn); },
+  };
+}
+
+
+
+test("待重启 + 面板可见 → 15 秒后自动重启(用户零操作),重启后 pending 结清即停止", async () => {
+  const plugin = loadPlugin({ status: statusWithRestart(true, 1111) });
+  let tree = await plugin.settle();
+  assert.ok(textHas(tree, "首次安装需要重启 DeepSeek harness"), "应显示待重启横幅");
+  assert.ok(textHas(tree, "秒后自动重启"), "应显示自动重启倒计时文案");
+  assert.equal(plugin.counts().restartCalls, 0, "倒计时期间不得提前重启");
+
+  await plugin.advance(14000);
+  assert.equal(plugin.counts().restartCalls, 0, "14 秒时还没到点");
+  await plugin.advance(2000);
+  assert.equal(plugin.counts().restartCalls, 1, "15 秒到点应自动重启一次");
+
+  tree = await plugin.settle();
+  assert.ok(!textHas(tree, "秒后自动重启"), "重启后不应残留倒计时");
+  await plugin.advance(60000);
+  assert.equal(plugin.counts().restartCalls, 1, "pending 结清后不得反复重启");
+});
+
+test("点「取消自动重启」→ 不再自动重启,且标记按事件持久化(刷新后仍不自动重启)", async () => {
+  const plugin = loadPlugin({ status: statusWithRestart(true, 2222) });
+  const tree = await plugin.settle();
+  const cancelBtn = nodeWithText(tree, "取消自动重启");
+  assert.ok(cancelBtn, "倒计时期间必须提供取消入口");
+  cancelBtn.props.onClick();
+  assert.ok(textHas(plugin.render(), "已取消自动重启"), "取消后应有明确反馈");
+
+  await plugin.advance(120000);
+  assert.equal(plugin.counts().restartCalls, 0, "取消后不得自动重启");
+
+  // 模拟用户刷新页面:同一 pending 事件(at=2222)仍不自动重启
+  const plugin2 = loadPlugin({ status: statusWithRestart(true, 2222), localStorage: { "dsh-remote-auto-restart-cancelled": "2222" } });
+  await plugin2.settle();
+  await plugin2.advance(120000);
+  assert.equal(plugin2.counts().restartCalls, 0, "刷新后仍尊重取消标记");
+
+  // 但下一次安装/更新(新的 at)应重新自动触发
+  const plugin3 = loadPlugin({ status: statusWithRestart(true, 3333), localStorage: { "dsh-remote-auto-restart-cancelled": "2222" } });
+  await plugin3.settle();
+  await plugin3.advance(16000);
+  assert.equal(plugin3.counts().restartCalls, 1, "新的待重启事件应重新自动重启");
+});
+
+test("面板不可见 → 倒计时暂停;回到前台继续", async () => {
+  const plugin = loadPlugin({ status: statusWithRestart(true, 4444) });
+  await plugin.settle();
+  plugin.hide();
+  await plugin.advance(60000);
+  assert.equal(plugin.counts().restartCalls, 0, "页面隐藏时绝不能在用户没看到的情况下重启进程");
+  plugin.show();
+  await plugin.advance(16000);
+  assert.equal(plugin.counts().restartCalls, 1, "回到前台应继续倒计时并最终重启");
+});
+
+test("无待重启 → 一个请求都不发;横幅不出现", async () => {
+  const plugin = loadPlugin({ status: LOGGED });
+  const tree = await plugin.settle();
+  await plugin.advance(60000);
+  assert.equal(plugin.counts().restartCalls, 0);
+  assert.ok(!textHas(tree, "自动重启"), "无待重启时不应出现自动重启文案");
+});

package/packages/dsh-remote-web/test/setup-output.test.mjs

@@ -0,0 +1,72 @@
+/**
+ * 安装脚本输出契约测试(node:test,零框架)。
+ *
+ * 背景:安装输出一度太长且重复 —— 同一段「下一步: 打开 dsh web → 设置 → 远程控制」
+ * 在插件阶段和结尾汇总各打印一遍,「已创建自启动服务」也打印两遍;更糟的是 dsh web
+ * 没开时只甩一句「自启动服务启动失败」,用户以为安装坏了(其实是正常状态:bridge 依赖
+ * dsh web,dsh web 没开时它起来即退)。
+ *
+ * 这里盯三条边界:
+ *  ① 输出里「下一步」引导只出现一次(去重不靠人眼);
+ *  ② dsh web 未运行 + bridge 未跑 → 明确说明"打开 dsh web 后会自动启动",且不出现
+ *     「启动失败」这种误导措辞;
+ *  ③ dsh web 在运行但 bridge 没跑 → 是真的异常,必须给出原因与日志路径。
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const SETUP = join(HERE, "..", "..", "..", "dsh-setup.mjs");
+
+const src = readFileSync(SETUP, "utf8");
+
+test("安装输出:拼接汇总时「下一步」引导只有一处文案源(不再多处重复打印)", () => {
+  // 引导语只由汇总的 L.push 产出:selfHosted 与非自建各一条(互斥分支,用户只会看到一条)
+  const pushes = src.match(/L\.push\("   下一步[:：]/g) || [];
+  assert.equal(pushes.length, 2, `「下一步」应只由汇总的 2 个互斥分支产出(实际 ${pushes.length} 处)`);
+  // 源码里不得再有其它直接打印引导的地方
+  const direct = src.match(/console\.log\((?!.*L\.join)[^)]*下一步/g) || [];
+  assert.equal(direct.length, 0, "除汇总外不得再直接打印引导");
+  // 插件阶段不得再打印用户引导
+  const converge = src.slice(src.indexOf("function convergePluginActivation"), src.indexOf("async function pluginCmd"));
+  assert.ok(!/下一步|打开 dsh web → 设置/.test(converge), "插件阶段不应再重复打印引导");
+});
+
+test("安装输出:「已创建自启动服务」路径只在汇总里打印一次", () => {
+  const createMsgs = src.match(/已创建自启动服务/g) || [];
+  assert.equal(createMsgs.length, 0, "创建路径不再单独打印(汇总里统一展示),避免同一信息两遍");
+  assert.ok(/自启动服务: \$\{svc\.path/.test(src), "汇总里应展示自启动服务路径");
+});
+
+test("安装输出:dsh web 未运行时的措辞 —— 说明会自动启动,且不出现「启动失败」误导", () => {
+  assert.ok(/async function isDshWebUp/.test(src), "应探测 dsh web 是否在运行(127.0.0.1:3080)");
+  const block = src.slice(src.indexOf("const webUp = await isDshWebUp();"));
+  // 未运行分支必须明说"会自动启动"
+  assert.ok(/dsh web 当前没有运行/.test(block), "未运行分支应直说检测结果");
+  assert.ok(/自动启动，无需任何命令/.test(block), "未运行分支应说明何时自动启动");
+  assert.ok(/不是安装出错/.test(block), "未运行分支应明确否定「安装出错」");
+  // 未运行分支的**用户可见文案**里不能出现「失败」(真失败分支才有)
+  const notUpBranch = block.slice(block.indexOf("if (!st.ok && !webUp)"), block.indexOf("} else if (!st.ok) {"));
+  // 只看 L.push(...) 的实参(注释里的说明文字不算用户可见文案)
+  const texts = (notUpBranch.match(/L\.push\((\s*)"([^"]*)"/g) || [])
+    .map((m) => (m.match(/"([^"]*)"/) || [])[1]).join("\n");
+  assert.ok(texts.length > 0, "该分支应有用户可见文案");
+  assert.ok(!/失败/.test(texts), `dsh web 未运行≠bridge 启动失败,该分支文案不得出现「失败」:\n${texts}`);
+});
+
+test("安装输出:真失败(dsh web 在运行但 bridge 没起来)必须给原因与日志路径", () => {
+  const block = src.slice(src.indexOf("const webUp = await isDshWebUp();"));
+  const failBranch = block.slice(block.indexOf("else if (!st.ok)"), block.indexOf("if (selfHosted) {", block.indexOf("else if (!st.ok)")));
+  assert.ok(/bridge 未能启动/.test(failBranch), "真失败分支要明说未能启动");
+  assert.ok(/\.dsh-bridge\.log/.test(failBranch), "真失败分支要给出日志路径供排查");
+});
+
+test("安装输出:服务状态字符串仍是插件面板可解析的稳定契约", () => {
+  // 插件半按 running / 未运行 解析,不能因为排版调整改口径
+  assert.ok(/\? `✅ 运行中/.test(src), "running 口径保留(带 pid)");
+  assert.ok(/`未运行 \(\$\{st\.detail \|\| st\.status\}\)`/.test(src), "未运行口径保留(带原因)");
+});