dsh-mini-remote 0.1.0 → 0.1.4

package/README.zh.md

@@ -1,138 +0,0 @@
-# dsh-mini-remote
-
-> 一个 [DeepSeek Harness](https://github.com/deepseek-ai/DeepSeek-Harness)（DSH）插件，把一部手机变成**极简遥控器**——手机端只收到你发出去的指令和 AI 最后的结论，工具调用、文件读写、子 Agent 调度、思考过程全部留在电脑上。
-
-![DSH plugin](https://img.shields.io/badge/DSH_plugin-dsh--plugin-blue)
-![License](https://img.shields.io/badge/license-MIT-green)
-
-[English →](README.md)
-
-**要在手机端使用该插件，请将 PC 端 DSH 会话页面切换到【完全权限】**——手机上点不了审批弹窗，会话会一直卡在那里等。
-
----
-
-## 为什么会有这个东西
-
-做这个插件的初衷是因为现在AGENT任务执行一轮往往需要很久，而如果出门，则需要手机端来远程操作。
-
-但现有的手机端，会把PC的执行步骤非常还原地展现出来。你发一条指令，它可能要想上几分钟、读几十个文件、调好几次工具，最后才给你一个结论。
-
-我并不认为这种方式不好。信息完整、过程可控，如果你要认真处理任务，它是对的。
-
-但出门在外的时候，就我个人而言，我需要的是另一种东西——**更轻便、更少占用注意力的交互方式**。手机屏幕就那么大，出门时的精力也就那么多。而大部分时候我真正需要的只有一件事：**这一轮跑完了，该发下一条指令了**。而且大部分时间，即使在电脑上，我也很少会去仔细阅读AI做执行过程中的“自言自语”。
-
-所以这个插件的界面做得相当「原始」：它完全省略了电脑网页端的执行步骤，只把 AI 最后的结论送到你面前。
-
-**某种意义上，它的存在，是为了让你更少地去看它。**
-
-你可以更加自由地支配自己的时间，而不是当你和女儿玩耍时，疑惑出游时，被困在那个小小的屏幕里。
-
----
-
-## 安装
-
-```powershell
-dsh plugin --profile web add github:xingzhen199186/dsh-mini-remote
-```
-
-包发布到 npm 之后，直接写包名也行：
-
-```powershell
-dsh plugin --profile web add dsh-mini-remote
-```
-
-手上有源码目录的话，把目录指给它也一样：
-
-```powershell
-dsh plugin --profile web add <你放源码的目录>
-```
-
-装完**必须重启一次 DSH**，设置页里才会出现新东西。重启后左栏会多出「手机遥控」，启动日志里也会打印手机访问地址和密码。
-
----
-
-## 配置：三条路，按需要选
-
-三条连接方式**同时存在**，选一条就行，也可以都开着。
-
-打开 DSH 设置（侧边栏最下面）→ 左栏「手机遥控」。这一页上每条路都有一个二维码和一条链接，二维码底下那行小字写着**什么时候用这条**，看它就够了。
-
-### 一、内网：只在家里用
-
-手机和电脑连同一个 Wi-Fi 时，扫「内网」那个码就能用。**不需要任何额外安装**，最省事的一条。
-
-代价是出了门就连不上——手机一切到流量，这条就断了。
-
-### 二、Tailscale：出门也能连，地址还固定
-
-电脑和手机都装上 [Tailscale](https://tailscale.com)、登录同一个账号，配对页上就会自动多出这一条。地址固定，配一次以后不用再管。
-
-代价是两边都要装一个 App。如果你不介意装，**出门在外这条最稳**。
-
-### 三、公网访问：什么都不用装
-
-配对页最底下有个开关，打开它，Cloudflare 会给你一个公网网址。手机在任何网络下都能连，**不用装任何东西**。
-
-两个代价，先知道再决定：
-
-- **地址每次重启 DSH 都会换**，换了得回来重新扫一次码。
-- **第一次打开会慢**——它在下载一个五十兆左右的组件，只下这一次。这期间状态那行会显示「正在打开…」，那是正常的，不是卡死。注册偶尔会失败，插件会自动重试 3 次。
-
-打开之后**等半分钟再扫**。Cloudflare 需要一点时间把这个地址公布出去，太早扫会提示打不开——那不是坏了，是还没到时候。
-
----
-
-<img width="1314" height="2186" alt="screenshot_20260922_233535_com huawei hmos brows" src="https://github.com/user-attachments/assets/8befa186-3e20-4c0e-8efc-8ea523f77648" />
-
-
-## 手机端能做什么
-
-打开链接就是全部界面：一个输入框，和最新的一条回复。
-
-**发指令。** 打字发出去，AI 就在电脑上开始干活。
-
-**等结论。** 跑的时候上面显示「运行中…」。这期间你可以接着发，指令会排队。任务结束，结论直接出现在页面上，同时响一声、震一下。
-
-**两种显示模式。** 点右上角的 ⚙ 切换。「单帧」（默认）整屏只留最新一条回复，适合「我就想看这次的结果」；「聊天」是一来一回的气泡列表，适合连着追问好几轮。用一阵子你会知道自己偏哪个。
-
-**看的是结论，不是过程。** 页面上没有工具调用链、没有文件 diff、没有审批弹窗——**需要你点确认的操作，手机上点不了**，得回电脑上处理。它也不替你在电脑上开新会话、切模型、改配置。它的定位是一根遥控器：电视还得在那儿开着，遥控器才有用。
-
----
-
-## 常见问题
-
-**扫码之后打不开。**
-先看手机和电脑是不是同一个 Wi-Fi。
-
-**出门扫「公网」那条打不开。**
-等半分钟再试。还不行的话，配对页上会直接显示原因。最常见的一种是**电脑上开着代理或 VPN**——Clash 这类软件的「TUN 模式」会把隧道的连接掐断，进程看着好好的，其实一条连接都没建立起来，先把它关掉再试。还有一种：这条网络就是走不通 Cloudflare（国内时好时坏，不是你哪里配错了），那就别在公网上耗着，**改用 Tailscale 那条**。
-
-**显示「未连接」。**
-手机切后台再回来经常会这样，页面会自己重连，等几秒；还不行就进设置点「重连」。
-
-**回复到了，但没声音。**
-声音要你先碰过页面才会响，点一下就行。
-
-**手机上一直让我输密码。**
-说明你打开的链接里没带密码（比如自己手打的地址）。回电脑上重新扫一次二维码就好。
-
-**想换一个自己记得住的密码。**
-在「设置 → 手机遥控」的密码那一块直接改，**至少 12 位**。改完要重启一次 DSH，重启之后手机上要重新扫一次码。
-
----
-
-## 安全
-
-**配对页上带着密码，别截图发出去。** 密码直接编在二维码里，扫完不用手敲——方便是方便，代价是谁拿到这张图谁就能进。
-
-除此之外：所有接口都要密码，密码比对用定长比较；同一来源一分钟错 5 次就挡一分钟；配对信息**只允许本机读取**，同一个 Wi-Fi 下的其他设备拿不到；公网隧道默认关着，要你自己在设置页里打开；手机拿不到你的文件系统。
-
----
-
-## 致谢
-
-这个插件在设计思路上参考过 [dsh-pocket](https://www.npmjs.com/package/dsh-pocket)（作者 shaobeichen）——尤其是「每条连接路径各配一条链接、一个二维码、一个密码」这种配置形态。
-
-## 许可
-
-MIT

package/client/verify.mjs

@@ -1,514 +0,0 @@
-// client/verify.mjs —— 手工验证 client/client.js 是否真的能用（零依赖、不需要测试框架）。
-//
-// 用法：node client/verify.mjs
-//
-// 做四件事：
-//   1. 伪造 window.__ModuleLoader__，把整个文件 eval 一遍，确认模块外壳被注册；
-//   2. 用 React 替身调用 factory，检查 exports（name / inject / apply）；
-//   3. 用假的 ctx 调 apply，检查注册进 settings.section 的 def 和组件；
-//   4. 用替身 React 真渲染一遍组件：加载中 → ok:false → ok:true → 网络错误，
-//      并点一次「复制」按钮，确认文案临时变成「已复制」。
-
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import assert from 'node:assert/strict';
-
-const here = dirname(fileURLToPath(import.meta.url));
-const source = readFileSync(join(here, 'client.js'), 'utf8');
-
-// ---------------------------------------------------------------- 小工具
-
-const tick = () => new Promise((resolve) => setImmediate(resolve));
-
-const setGlobal = (name, value) =>
-  Object.defineProperty(globalThis, name, { value, configurable: true, writable: true });
-
-/** 把渲染树摊平成纯文本，用来断言界面上出现了哪些字。 */
-function textOf(node) {
-  if (node === null || node === undefined || typeof node === 'boolean') return '';
-  if (typeof node === 'string' || typeof node === 'number') return String(node);
-  if (Array.isArray(node)) return node.map(textOf).join(' ');
-  return textOf(node.children);
-}
-
-/** 收集渲染树里所有元素节点（深度优先）。 */
-function walk(node, out = []) {
-  if (node === null || node === undefined || typeof node !== 'object') return out;
-  if (Array.isArray(node)) {
-    for (const child of node) walk(child, out);
-    return out;
-  }
-  out.push(node);
-  walk(node.children, out);
-  return out;
-}
-
-const byType = (tree, type) => walk(tree).filter((node) => node.type === type);
-
-/**
- * 最小 React 替身 + 最小渲染循环。
- * createElement 返回普通对象；useState 真的能改状态并触发重渲染；
- * useEffect 不在渲染时执行，由 runEffects() 显式跑一次（和 React 一致）。
- */
-function createHarness() {
-  const cells = [];
-  let cursor = 0;
-  let pending = [];
-  let cleanups = [];
-  let onUpdate = null;
-
-  const React = {
-    createElement(type, props, ...children) {
-      return { type, props: props || {}, children };
-    },
-    useState(initial) {
-      const i = cursor++;
-      if (i >= cells.length) cells.push(typeof initial === 'function' ? initial() : initial);
-      const set = (next) => {
-        cells[i] = typeof next === 'function' ? next(cells[i]) : next;
-        if (onUpdate) onUpdate();
-      };
-      return [cells[i], set];
-    },
-    useEffect(fn) { pending.push(fn); },
-    useRef(initial) { return { current: initial }; },
-  };
-
-  return {
-    React,
-    /** 渲染一次；重渲染会丢掉上一次登记的 effect（等价于依赖数组没变时不重跑）。 */
-    draw(Comp) { cursor = 0; pending = []; return Comp({}); },
-    runEffects() {
-      const fns = pending;
-      pending = [];
-      for (const fn of fns) {
-        const dispose = fn();
-        if (typeof dispose === 'function') cleanups.push(dispose);
-      }
-    },
-    unmount() { for (const dispose of cleanups) dispose(); cleanups = []; },
-    onUpdate(fn) { onUpdate = fn; },
-  };
-}
-
-/**
- * 组件在 factory 里就把 React.useState/useEffect 绑进了工厂闭包，所以替身必须是
- * 一个稳定的门面对象，内部转发给「当前这一套状态」——否则第二套 harness 永远不生效。
- */
-let active = null;
-const ReactFacade = {
-  createElement: (type, props, ...children) => active.React.createElement(type, props, ...children),
-  useState: (initial) => active.React.useState(initial),
-  useEffect: (fn) => active.React.useEffect(fn),
-  useRef: (initial) => active.React.useRef(initial),
-};
-
-/** 新建一套状态单元并设为当前（每个渲染用例一套，互不干扰）。 */
-function useHarness() {
-  active = createHarness();
-  return active;
-}
-
-/** 假的 fetch 响应。 */
-const jsonResponse = (status, body) => ({
-  status,
-  json: async () => body,
-});
-
-// ---------------------------------------------------------------- 断言运行器
-
-let passed = 0;
-const failures = [];
-
-async function check(label, fn) {
-  try {
-    await fn();
-    passed += 1;
-    console.log(`  ✓ ${label}`);
-  } catch (err) {
-    failures.push({ label, err });
-    console.log(`  ✗ ${label}`);
-    console.log(`      ${err && err.message ? err.message : err}`);
-  }
-}
-
-// ---------------------------------------------------------------- 1. 模块外壳
-
-let captured = null;
-setGlobal('window', { __ModuleLoader__: { load: (registration) => { captured = registration; } } });
-(0, eval)(source); // 间接 eval：在全局作用域执行，模拟浏览器加载这个脚本
-
-console.log('\n[1] 模块外壳 window.__ModuleLoader__.load');
-
-await check('文件执行后捕获到一次注册', () => {
-  assert.ok(captured, '没有调用 window.__ModuleLoader__.load');
-});
-await check('id === "dsh-mini-remote"', () => {
-  assert.equal(captured.id, 'dsh-mini-remote');
-});
-await check('factory 是函数', () => {
-  assert.equal(typeof captured.factory, 'function');
-});
-
-// ---------------------------------------------------------------- 2. factory / exports
-
-const harness = useHarness();
-const required = [];
-const fakeRequire = (spec) => {
-  required.push(spec);
-  if (spec === 'react') return ReactFacade;
-  throw new Error(`客户端模块只允许 require("react")，实际请求了 "${spec}"`);
-};
-
-let mod = null;
-console.log('\n[2] factory(require) 的返回值');
-await check('factory 不抛错并返回 exports', () => {
-  mod = captured.factory(fakeRequire);
-  assert.ok(mod && typeof mod === 'object');
-});
-await check('只 require 了 react（零运行时依赖）', () => {
-  assert.deepEqual(required, ['react']);
-});
-await check('exports.name === "dsh-mini-remote"', () => {
-  assert.equal(mod.name, 'dsh-mini-remote');
-});
-await check("exports.inject 深等于 ['slots']", () => {
-  assert.deepEqual(mod.inject, ['slots']);
-});
-await check('exports.apply 是函数', () => {
-  assert.equal(typeof mod.apply, 'function');
-});
-
-// ---------------------------------------------------------------- 3. apply / slots 注册
-
-const injected = [];
-const registered = [];
-const fakeCtx = {
-  slots: {
-    inject(name, callback) { injected.push(name); return callback(); },
-    register(def, Comp) { registered.push({ def, Comp }); return () => {}; },
-  },
-};
-
-let Comp = null;
-let def = null;
-console.log('\n[3] apply(ctx) 的 slots 注册');
-await check('apply(fakeCtx) 不抛错', () => {
-  assert.doesNotThrow(() => mod.apply(fakeCtx));
-});
-await check('inject 的服务名是 "settings.section"', () => {
-  assert.deepEqual(injected, ['settings.section']);
-});
-await check('register 只调用了一次', () => {
-  assert.equal(registered.length, 1);
-});
-await check('def.name === "settings.section"', () => {
-  def = registered[0].def;
-  assert.equal(def.name, 'settings.section');
-});
-await check('def.id === "mini-remote"', () => {
-  assert.equal(def.id, 'mini-remote');
-});
-await check('def.order === 2', () => {
-  assert.equal(def.order, 2);
-});
-await check('def.label 是函数（typeof === "function"）', () => {
-  assert.equal(typeof def.label, 'function');
-});
-await check('def.label() === "手机遥控"', () => {
-  assert.equal(def.label(), '手机遥控');
-});
-await check('第二个参数是组件函数', () => {
-  Comp = registered[0].Comp;
-  assert.equal(typeof Comp, 'function');
-});
-
-// ---------------------------------------------------------------- 4. 渲染组件
-
-const TOKEN = '0123456789abcdef0123456789abcdef';
-const URL_LAN = `http://192.168.1.2:3090/mini?token=${TOKEN}`;
-const URL_TS = `http://100.92.105.99:3090/mini?token=${TOKEN}`;
-const QR = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==';
-
-console.log('\n[4] 组件渲染');
-
-// 4a. 加载中
-let resolveFetch = null;
-setGlobal('fetch', () => new Promise((resolve) => { resolveFetch = resolve; }));
-{
-  const h4 = useHarness();
-  let tree = null;
-  h4.onUpdate(() => { tree = h4.draw(Comp); });
-  await check('挂载时不抛错，并显示「正在读取配对信息…」', () => {
-    tree = h4.draw(Comp);
-    assert.notEqual(tree, undefined);
-    assert.match(textOf(tree), /正在读取配对信息…/);
-  });
-  await check('useEffect 里发起了同源 GET /mini-remote/pairing', () => {
-    h4.runEffects();
-    assert.equal(typeof resolveFetch, 'function', 'useEffect 里没有发起 fetch');
-  });
-  await check('顶部两句说明都在', () => {
-    const text = textOf(tree);
-    assert.match(text, /手机扫码就能用，不用输密码——密码已经编在二维码里了。/);
-    assert.match(text, /这个页面带着密码，别截图发出去。/);
-  });
-  await check('HTTP 403 + {ok:false,error} → 显示 error 原文', async () => {
-    resolveFetch(jsonResponse(403, { ok: false, error: '配对信息只能在这台电脑上看。' }));
-    await tick();
-    assert.match(textOf(tree), /配对信息只能在这台电脑上看。/);
-    assert.doesNotMatch(textOf(tree), /正在读取配对信息…/);
-  });
-}
-
-// 4b. 网络错误（fetch 直接失败）
-{
-  const h4 = useHarness();
-  setGlobal('fetch', () => Promise.reject(new Error('Failed to fetch')));
-  let tree = null;
-  h4.onUpdate(() => { tree = h4.draw(Comp); });
-  await check('网络错误 → 显示失败原因，不吞掉', async () => {
-    tree = h4.draw(Comp);
-    h4.runEffects();
-    await tick();
-    assert.match(textOf(tree), /连不上这台电脑上的遥控服务：Failed to fetch/);
-  });
-}
-
-// 4c. 成功：两条 entry（第二条没有二维码）
-{
-  const h4 = useHarness();
-  setGlobal('fetch', async () => jsonResponse(200, {
-    ok: true,
-    port: 3090,
-    token: TOKEN,
-    entries: [
-      { kind: 'lan', label: '内网', hint: '手机连同一个 Wi-Fi 时用这个', url: URL_LAN, qr: QR },
-      { kind: 'tailscale', label: 'Tailscale', hint: '在外面也能用', url: URL_TS, qr: null },
-    ],
-  }));
-  let tree = null;
-  h4.onUpdate(() => { tree = h4.draw(Comp); });
-
-  await check('ok:true 时渲染两块 entry（label + hint）', async () => {
-    tree = h4.draw(Comp);
-    h4.runEffects();
-    await tick();
-    const text = textOf(tree);
-    assert.match(text, /内网/);
-    assert.match(text, /手机连同一个 Wi-Fi 时用这个/);
-    assert.match(text, /Tailscale/);
-    assert.match(text, /在外面也能用/);
-    assert.doesNotMatch(text, /正在读取配对信息…/);
-  });
-
-  await check('二维码渲染成 <img src={entry.qr}>（宽 180）', () => {
-    const imgs = byType(tree, 'img');
-    assert.equal(imgs.length, 1, '有 qr 的只有一条，qr:null 的那条应退化成文字');
-    assert.equal(imgs[0].props.src, QR);
-    assert.equal(imgs[0].props.style.width, 180);
-  });
-
-  await check('两条 URL 都在只读 <input> 里，不是纯文本 div', () => {
-    // 按内容找，不按位置也不数总数：面板上还有别的输入框（密码、改密码那两处），
-    // 数总数的话，每加一个输入框这里都要误报一次。
-    const urls = byType(tree, 'input').filter((n) => n.props.value === URL_LAN || n.props.value === URL_TS);
-    assert.equal(urls.length, 2);
-    assert.equal(urls[0].props.readOnly, true);
-    assert.equal(urls[1].props.readOnly, true);
-  });
-
-  await check('点输入框会全选地址', () => {
-    let selected = false;
-    const lan = byType(tree, 'input').find((n) => n.props.value === URL_LAN);
-    lan.props.onFocus({ target: { select() { selected = true; } } });
-    assert.equal(selected, true);
-  });
-
-  await check('qr 为 null 时退化成文字，界面不崩', () => {
-    assert.match(textOf(tree), /二维码没画出来/);
-  });
-
-  await check('每条链接各有一个「复制」按钮，初始文案是「复制」', () => {
-    // 同样按文案找，不数总数：密码那一块也有「复制」。
-    const copies = byType(tree, 'button').filter((b) => textOf(b) === '复制');
-    assert.ok(copies.length >= 2, '两条链接各要有一个「复制」按钮');
-    assert.equal(textOf(copies[0]), '复制');
-    assert.equal(textOf(copies[1]), '复制');
-  });
-
-  // 2026-09-22 用户报：「手机遥控页面里似乎根本没有密码，也无法自定义密码」。
-  // 配对接口一直返回着 token，只是没人渲染它——这三项钉住它真的露出来了。
-  await check('密码默认打码显示，不是明文', () => {
-    const masked = TOKEN.replace(/./g, '•');
-    const pw = byType(tree, 'input').find((n) => n.props.value === masked);
-    assert.ok(pw, '默认该显示打码后的密码');
-    assert.equal(pw.props.readOnly, true, '密码框只能看，不能改——改要走保存那条路');
-    assert.ok(!byType(tree, 'input').some((n) => n.props.value === TOKEN), '没点「显示」之前不该出现明文');
-  });
-
-  await check('点「显示」→ 明文，再点「藏起来」→ 又打码', async () => {
-    const masked = TOKEN.replace(/./g, '•');
-    const showBtn = byType(tree, 'button').find((b) => textOf(b) === '显示');
-    assert.ok(showBtn, '要有一个「显示」按钮');
-    showBtn.props.onClick();
-    await tick();
-    tree = h4.draw(Comp);
-    assert.ok(byType(tree, 'input').some((n) => n.props.value === TOKEN), '点过之后应显示明文');
-    const hideBtn = byType(tree, 'button').find((b) => textOf(b) === '藏起来');
-    assert.ok(hideBtn, '显示之后按钮该变成「藏起来」');
-    hideBtn.props.onClick();
-    await tick();
-    tree = h4.draw(Comp);
-    assert.ok(byType(tree, 'input').some((n) => n.props.value === masked), '再点一次该变回打码');
-  });
-
-  await check('点密码旁边的「复制」→ 复制的是密码本身', async () => {
-    const written = [];
-    setGlobal('navigator', { clipboard: { writeText: async (text) => { written.push(text); } } });
-    // 链接那两个「复制」在前，密码那个在最后
-    const copies = byType(tree, 'button').filter((b) => textOf(b) === '复制');
-    copies[copies.length - 1].props.onClick();
-    await tick();
-    assert.deepEqual(written, [TOKEN]);
-  });
-
-  await check('点「复制」→ navigator.clipboard.writeText(url)，文案变「已复制」', async () => {
-    const written = [];
-    setGlobal('navigator', { clipboard: { writeText: async (text) => { written.push(text); } } });
-    byType(tree, 'button')[0].props.onClick();
-    await tick();
-    assert.deepEqual(written, [URL_LAN]);
-    const buttons = byType(tree, 'button');
-    assert.equal(textOf(buttons[0]), '已复制');
-    assert.equal(textOf(buttons[1]), '复制', '只改被点的那一个');
-  });
-
-  await check('复制失败时不谎报「已复制」', async () => {
-    const h5 = useHarness();
-    let tree5 = null;
-    h5.onUpdate(() => { tree5 = h5.draw(Comp); });
-    tree5 = h5.draw(Comp);
-    h5.runEffects();
-    await tick();
-    setGlobal('navigator', { clipboard: { writeText: async () => { throw new Error('NotAllowedError'); } } });
-    byType(tree5, 'button')[0].props.onClick();
-    await tick();
-    assert.equal(textOf(byType(tree5, 'button')[0]), '复制');
-  });
-}
-
-// 4d. 公网访问：开关、状态、报错、以及 ok:false 时也要能关掉它
-{
-  const withTunnel = (tunnel, extra) => Object.assign({
-    ok: true,
-    port: 3090,
-    token: TOKEN,
-    entries: [{ kind: 'lan', label: '内网', hint: '手机连同一个 Wi-Fi 时用这个', url: URL_LAN, qr: QR }],
-    tunnel,
-  }, extra || {});
-
-  const h6 = useHarness();
-  let tree6 = null;
-  let posted = [];
-  h6.onUpdate(() => { tree6 = h6.draw(Comp); });
-
-  const mount = async (payload) => {
-    setGlobal('fetch', async (url, init) => {
-      if (init && init.method === 'POST') {
-        posted.push({ url, body: JSON.parse(init.body) });
-        return jsonResponse(200, withTunnel({ enabled: JSON.parse(init.body).enabled, up: false, starting: false, error: null }));
-      }
-      return jsonResponse(200, payload);
-    });
-    tree6 = h6.draw(Comp);
-    h6.runEffects();
-    await tick();
-  };
-
-  await check('公网没开时：开关是未选中的，并且说明「出门进不来」', async () => {
-    await mount(withTunnel({ enabled: false, up: false, starting: false, error: null }));
-    const boxes = byType(tree6, 'input').filter((n) => n.props.type === 'checkbox');
-    assert.equal(boxes.length, 1, '要有一个公网开关');
-    assert.equal(boxes[0].props.checked, false);
-    const text = textOf(tree6);
-    assert.match(text, /公网访问/);
-    assert.match(text, /手机不连家里 Wi-Fi 的时候就进不来/);
-  });
-
-  await check('公网开着且有地址时：开关选中，提示去看「公网」那条', async () => {
-    await mount(withTunnel({ enabled: true, up: true, starting: false, error: null }));
-    const boxes = byType(tree6, 'input').filter((n) => n.props.type === 'checkbox');
-    assert.equal(boxes[0].props.checked, true);
-    const text = textOf(tree6);
-    assert.match(text, /上面那条「公网」/);
-    assert.match(text, /每次重启 DSH 都会换一个/, '要提前说清楚地址会变');
-    assert.match(text, /挂在公网上/, '开了要提醒它现在暴露在公网');
-  });
-
-  await check('公网开着但连不上时：原文报错照登，不吞掉', async () => {
-    await mount(withTunnel({ enabled: true, up: false, starting: false, error: '所有下载源都没成功：\n  github.com — 超时' }));
-    const text = textOf(tree6);
-    assert.match(text, /开着，但公网那边连不上/, '要让用户知道这条路现在是死的');
-    assert.match(text, /所有下载源都没成功/, '底层原因要透出来，否则没法排查');
-    assert.match(text, /github\.com — 超时/);
-  });
-
-  // 2026-09-22 用户照着一个写着「已开启」的面板去扫码，扫出来是 Cloudflare 的 Error 1033。
-  // 这两种情况必须分开说：**还在等地址**和**地址拿到过、后来断了**，用户的下一步动作不同。
-  await check('公网开着、没有报错时：说的是「还没拿到地址」，不是「连不上」', async () => {
-    await mount(withTunnel({ enabled: true, up: false, starting: false, error: null }));
-    const text = textOf(tree6);
-    assert.match(text, /已开启，但还没拿到公网地址/);
-    assert.doesNotMatch(text, /公网那边连不上/, '还没报错就不该先吓唬人');
-  });
-
-  await check('正在打开时：开关禁用，避免连点起出好几条隧道', async () => {
-    await mount(withTunnel({ enabled: true, up: false, starting: true, error: null }));
-    const boxes = byType(tree6, 'input').filter((n) => n.props.type === 'checkbox');
-    assert.equal(boxes[0].props.disabled, true);
-    assert.match(textOf(tree6), /正在打开/);
-  });
-
-  await check('勾上开关 → POST /mini-remote/tunnel，body 是 {enabled:true}', async () => {
-    posted = [];
-    await mount(withTunnel({ enabled: false, up: false, starting: false, error: null }));
-    const box = byType(tree6, 'input').filter((n) => n.props.type === 'checkbox')[0];
-    box.props.onChange({ target: { checked: true } });
-    await tick();
-    assert.equal(posted.length, 1, '只该发一次请求');
-    assert.equal(posted[0].url, '/mini-remote/tunnel');
-    assert.deepEqual(posted[0].body, { enabled: true });
-  });
-
-  await check('关掉开关 → body 是 {enabled:false}', async () => {
-    posted = [];
-    await mount(withTunnel({ enabled: true, up: true, starting: false, error: null }));
-    const box = byType(tree6, 'input').filter((n) => n.props.type === 'checkbox')[0];
-    box.props.onChange({ target: { checked: false } });
-    await tick();
-    assert.equal(posted.length, 1);
-    assert.deepEqual(posted[0].body, { enabled: false });
-  });
-
-  await check('整块面板报错时，公网开关仍然露得出来', async () => {
-    // 否则「隧道起不来」会把面板变成一条报错，用户连关掉它的地方都找不到
-    await mount(withTunnel(
-      { enabled: true, up: false, starting: false, error: '找不到 cloudflared' },
-      { ok: false, error: '公网访问没起来：找不到 cloudflared', entries: undefined },
-    ));
-    const boxes = byType(tree6, 'input').filter((n) => n.props.type === 'checkbox');
-    assert.equal(boxes.length, 1, '报错时也得能点得动开关');
-    assert.equal(boxes[0].props.checked, true);
-    assert.match(textOf(tree6), /公网访问没起来/);
-  });
-}
-
-// ---------------------------------------------------------------- 结果
-
-console.log(`\n通过 ${passed} 项，失败 ${failures.length} 项。`);
-if (failures.length) {
-  for (const { label, err } of failures) console.log(`  ✗ ${label}: ${err && err.stack ? err.stack : err}`);
-  process.exitCode = 1;
-}