dsh-mini-remote 0.1.0 → 0.1.3

package/lib/store.js

@@ -84,6 +84,71 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
     queueSource = typeof fn === 'function' ? fn : () => []
   }
 
+  /**
+   * 「这个会话**完整**的历史」从哪儿问。
+   *
+   * 和 queueSource 同一个道理、同一套写法：真相在 DSH 自己的会话记录里
+   * （`sessionQuery.readSession`），而 store 拿不到 ctx，所以由插件注入一个回调。
+   * 回调返回 `{ entries, latest, pending }`；没读过这个会话时返回 null。
+   *
+   * **为什么不把读出来的历史塞进 `state.historyBySession`**：那一份是要落盘的，
+   * 而且是 500 毫秒写一次整个 JSON。几百条历史灌进去，等于每半秒重写一遍几百 KB
+   * 的文件。所以完整历史只活在内存里，落盘的仍然是「插件亲眼看过的事件」。
+   */
+  let replaySource = null
+
+  function setReplaySource(fn) {
+    replaySource = typeof fn === 'function' ? fn : null
+  }
+
+  /**
+   * 展示用的聊天记录 = **硬盘那份（完整）+ 还没来得及落进日志的那几条**。
+   *
+   * 硬盘那份是 DSH 自己写的日志，权威且完整；内存那份只在两种情况下有用：
+   * ① 硬盘那份还没读出来（刚点进去的那一下）；② 刚发生、日志里还没有的那一条。
+   * 所以规则是：以硬盘那份为主，把时间戳比它最后一条更新的内存条目接在后面。
+   * 两边的钟是同一台机器的（事件的 `time` 与记录时的 `Date.now()`），不会接重或接丢。
+   *
+   * **斜杠指令要多一道手续**：同一条指令可能在硬盘那份里还写着「执行中」——读日志的
+   * 那一瞬间它**确实还在跑**（`/compact` 要跑十几秒，而一分钟会重读一次日志，撞上的
+   * 机会不小）。手里这份后来收到了 `command/done`，可它的时间戳和硬盘那条**一样**
+   * （同一条 `command/run` 事件），按上面的时间戳规则接不上去，于是手机上会一直挂着
+   * 「执行中」，直到下一次重读——最多一分钟。所以指令行按 `commandId` 认人：
+   * 硬盘那条就地改成手里这份的结果，然后**不能**再把它接一遍。
+   */
+  function mergeHistory(live, disk) {
+    if (!disk || !disk.length) return live
+    if (!live.length) return disk
+    const settled = new Map()
+    for (const m of live) {
+      if (m?.role === 'command' && m.commandId && m.kind !== 'running') settled.set(m.commandId, m)
+    }
+    const mergedInto = new Set()
+    const merged = settled.size
+      ? disk.map((m) => {
+        if (m?.role !== 'command' || !m.commandId) return m
+        const better = settled.get(m.commandId)
+        if (!better) return m
+        mergedInto.add(m.commandId)
+        return { ...m, kind: better.kind, text: better.text }
+      })
+      : disk
+    const last = merged[merged.length - 1].timestamp ?? 0
+    const tail = live.filter((m) => {
+      // 刚在上面并进去的那几条，不能再作为「新的一条」接一遍。
+      if (m?.role === 'command' && m.commandId && mergedInto.has(m.commandId)) return false
+      return (m.timestamp ?? 0) > last
+    })
+    return tail.length ? merged.concat(tail) : merged
+  }
+
+  /** 单帧模式显示哪一条：两份里取时间更新的那条。 */
+  function newestLatest(a, b) {
+    if (!a) return b
+    if (!b) return a
+    return (b.timestamp ?? 0) > (a.timestamp ?? 0) ? b : a
+  }
+
   /** 某个会话的最新回复；没有就是 null。 */
   function latestOf(sessionId) {
     return sessionId ? (state.latestBySession[sessionId] ?? null) : null
@@ -214,6 +279,9 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
     /** 告诉 store「队列里有什么」该去哪儿问（见 setQueueSource）。 */
     setQueueSource,
 
+    /** 告诉 store「这个会话完整的历史」该去哪儿问（见 setReplaySource）。 */
+    setReplaySource,
+
     /** 某个会话的最新回复 / 聊天记录。 */
     latestOf,
     historyOf,
@@ -250,6 +318,46 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
       persist()
     },
 
+    /**
+     * 一条斜杠指令开跑了（`command/run`）。
+     *
+     * 指令是**第三种东西**：不是用户说的话，也不是模型的回答。所以在聊天记录里
+     * 单独一个 role，界面上按「系统动作」画。混进用户气泡会让「这句到底是谁说的」
+     * 变糊——手机上看聊天记录时这个判断最要紧。
+     */
+    pushCommand({ sessionId, commandId, name, args, timestamp }) {
+      pushHistory(sessionId, {
+        role: 'command', commandId, name, args: args ?? '', kind: 'running', text: null,
+        // 时间戳用事件自己的 `time`（事件里带过来的），不是 Date.now()：
+        // 这一条要和硬盘重放出来的那份按时间戳合成，两边得用同一个钟。
+        timestamp: timestamp ?? Date.now(), sessionId,
+      })
+      persist()
+    },
+
+    /**
+     * 那条指令收尾了（`command/done`）：**就地改那一条，不新加一条**。
+     *
+     * 认 commandId 从后往前找——同一条会话里同时跑两条同名指令是可能的，
+     * 按名字找会改错行。
+     *
+     * 找不到就什么都不做：这只可能是「插件是中途起来的、没看见 run」。
+     * 下一次读日志（点开会话时、或六十秒内那一次）会把这一对完整地重放出来，
+     * 那时候它自然就在了。**不能**在这儿补一条没有名字的记录——那比晚几十秒更糟。
+     */
+    settleCommand({ sessionId, commandId, kind, text }) {
+      const list = historyOf(sessionId)
+      for (let i = list.length - 1; i >= 0; i--) {
+        const m = list[i]
+        if (m.role === 'command' && m.commandId === commandId) {
+          m.kind = kind
+          m.text = text ?? null
+          persist()
+          return
+        }
+      }
+    },
+
     /**
      * 清空**当前会话**在单帧模式里的内容。
      *
@@ -288,15 +396,39 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
 
     snapshot() {
       const target = targetSessionId()
+      // 内存里记着的那一份（插件在场时看见的）
+      const live = historyOf(target)
+      // DSH 记录里那一份（完整），没读过就是 null；读取中 pending 为 true
+      const replay = target && replaySource ? replaySource(target) : null
       return {
         /**
          * latest 和 history 都是**当前这个会话**的那一份。
          *
          * 原来是全局一份，于是切到别的会话时，单帧模式里还显示着上一个会话的答案
          * （2026-09-21 用户实机报的）。和 running 一样，显示状态不能跨会话串。
+         *
+         * 现在两份来源合成一份：内存里那份（插件亲眼看见的）和 DSH 记录里那份（完整）。
+         * 合成规则见 mergeHistory / newestLatest——**只看时间戳，不猜**。
+         */
+        latest: newestLatest(latestOf(target), replay?.latest ?? null),
+        history: mergeHistory(live, replay?.entries ?? null),
+        /**
+         * 「正在去读这个会话的记录」。
+         *
+         * 手机点开一个从没看过的会话时，读它的日志要一会儿（实测最大的那条 20 MB、
+         * 约半秒）。这期间内存里空空如也，界面该说「正在读」而不是「还没有对话记录」——
+         * 后者会让用户以为这个会话是空的。
+         */
+        historyLoading: replay?.pending === true && live.length === 0,
+        /**
+         * 「这份历史不是全部，只到最近一段」。
+         *
+         * 读历史有上限（见 index.js 的 HISTORY_MAX_ENTRIES / 尾部窗口）：会话太大时
+         * 只读日志尾部。**必须跟着内容一起说出去**——否则用户会以为这个会话就这么点。
          */
-        latest: latestOf(target),
-        history: historyOf(target),
+        historyTruncated: replay?.truncated === true,
+        /** 给手机的一句人话（为什么不是全部）；null = 不用解释。 */
+        historyNote: replay?.note ?? null,
         /**
          * 正在流出来的那一段（可能为空）。
          *

package/lib/sw.js

@@ -0,0 +1,39 @@
+/**
+ * Service worker —— 它只为一件存在：让手机能发**系统通知**。
+ *
+ * 为什么非要有它：手机浏览器上 `new Notification()` 会直接抛 TypeError，
+ * 唯一能发系统通知的入口是 `ServiceWorkerRegistration.showNotification()`。
+ * 换句话说，「锁屏也能收到提醒」这件事的前提，是先有一个 service worker。
+ *
+ * 它自己不做任何后台工作：不缓存、不拦截请求、不在后台跑逻辑。收到页面递来的
+ * 一句话就发一条通知，用户点了就回到页面。就这样。
+ *
+ * 2026-09-25 才加。在此之前这条路是关着的——service worker 要求安全上下文，
+ * 而当时三条连接路径全是明文 http。Tailscale 那条路接上 HTTPS 之后才成立。
+ *
+ * **注意作用域**：页面在 `/mini`，不在 `/mini/` 底下。这个文件从 `/mini/sw.js`
+ * 发出去，默认作用域只到 `/mini/`，够不着那个页面。所以服务器发它的时候必须带上
+ * `Service-Worker-Allowed: /`（见 lib/server.js），把作用域放开到根。
+ */
+
+// 新的立刻接管。它没有任何状态要迁移，不该让用户「刷新两次才生效」。
+self.addEventListener('install', () => self.skipWaiting())
+self.addEventListener('activate', (event) => event.waitUntil(self.clients.claim()))
+
+// 通知由页面直接调 `registration.showNotification()` 发出，不经过这里——
+// 页面本来就能调那个方法，绕一道消息传递只是多一层可能出错的地方。
+// 这个文件在这儿只负责两件页面做不到的事：**让注册成立**，以及**接住点击**。
+self.addEventListener('notificationclick', (event) => {
+  event.notification.close()
+  const url = event.notification.data && event.notification.data.url
+  event.waitUntil(
+    (async () => {
+      const all = await self.clients.matchAll({ type: 'window', includeUncontrolled: true })
+      // 页面已经开着就切过去，别再开一个——用户要的是「回到刚才那页」。
+      for (const c of all) {
+        if (typeof c.focus === 'function') return c.focus()
+      }
+      if (url && self.clients.openWindow) return self.clients.openWindow(url)
+    })(),
+  )
+})

package/lib/tree.js

@@ -15,6 +15,8 @@
  * 它的会话（要读日志折标题，贵）。
  */
 import { basename } from 'node:path'
+import { statSync } from 'node:fs'
+import { findSessionLog } from './log-tail.js'
 
 /** 一个工作区默认最多列多少会话。手机上再多也划不动。 */
 export const SESSIONS_PER_WORKSPACE = 20
@@ -107,15 +109,21 @@ function titleText(value) {
 }
 
 /**
- * 工作区列表。只给「有会话可切」的那些，空工作区不占地方。
+ * 工作区列表。默认只给「有会话可切」的那些，空工作区不占地方。
  * 返回顺序就是桌面端的显示顺序。
+ *
+ * `includeEmpty`：把一条会话都没有的工作区也列出来。
+ * **手机端必须开着这个**——手机现在能自己新建工作区了，一个刚建好的工作区
+ * 本来就是空的；要是列表把它滤掉，用户建完它就当场消失，只会以为没建成。
+ * （闸门脚本就是这么逮到的：接口回 created=true，列表里却找不到。）
+ * 默认仍然是「滤掉」，桌面端那些老调用方的行为一点不变。
  */
-export async function listWorkspaces({ registry, query, runningIds, force }) {
+export async function listWorkspaces({ registry, query, runningIds, force, includeEmpty }) {
   const byId = toRecordMap(await safeRecords(query, { force }))
   const out = []
   for (const ws of safeList(registry)) {
     const ids = (ws.sessionIds ?? []).filter((id) => visible(byId.get(id)))
-    if (!ids.length) continue
+    if (!ids.length && !includeEmpty) continue
     let running = 0
     for (const id of ids) if (runningIds?.has(id)) running += 1
     out.push({
@@ -125,11 +133,109 @@ export async function listWorkspaces({ registry, query, runningIds, force }) {
       path: ws.path || '',
       count: ids.length,
       running,
+      // 手机据此决定是「展开看会话」还是直接提示「这里还没有会话，可以建一个」。
+      empty: ids.length === 0,
     })
   }
   return out
 }
 
+/**
+ * 在一个已有的工作区里新建一个会话。
+ *
+ * **走 DSH 自己那条路**：`sessionController.create({ workspaceId })`——就是网页端
+ * 点「新建会话」时走的那条。不自己拼会话，理由是装配一个能用的会话远不止「起个 id」：
+ * 要先装模型选择（`agentDefaultModel`），再把 agent preset 挂到它的作用域上
+ * （工具、指令、技能全在那里面），最后才注册进 sessions 和 agents 两张表。
+ * 这些都在 `dsh-api-session-controller` 内部，抄一遍等于把 DSH 的内部结构复制到
+ * 我们这儿，它一改我们就散架。它自己也是拿 `ctx.agents.create(...)` 做的，
+ * 而 `ctx.agents` 就是注入给我们的那个 AgentRegistry。
+ *
+ * 三种失败分得开，因为手机上的说法不一样：
+ *   - `no-controller` 这台电脑上的 DSH 没提供会话服务（headless 组合里没有）
+ *   - `no-workspace`  工作区不在了（桌面端刚把它删掉）
+ *   - `failed`        DSH 拒绝了，原因原样带回
+ */
+export async function createSessionIn({ controller, registry, workspaceId }) {
+  if (!controller || typeof controller.create !== 'function') {
+    return { ok: false, reason: 'no-controller' }
+  }
+  const ws = safeList(registry).find((w) => w.id === workspaceId)
+  if (!ws) return { ok: false, reason: 'no-workspace' }
+
+  let created
+  try {
+    created = await controller.create({ workspaceId })
+  } catch (err) {
+    return { ok: false, reason: 'failed', error: String(err?.message ?? err) }
+  }
+  // 建成了就必须有 id。没有 id 的话手机没法绑过去，等于白建——宁可报错也不装作成功。
+  const sessionId = created?.sessionId
+  if (typeof sessionId !== 'string' || sessionId === '') {
+    return { ok: false, reason: 'failed', error: 'DSH 建了会话但没返回 id' }
+  }
+  return {
+    ok: true,
+    sessionId,
+    // 手机建完要显示一句「已在《xxx》里建好」，所以顺手把标题带回去。
+    workspaceTitle: (ws.title || '').trim() || basename(ws.path || '') || '未命名工作区',
+  }
+}
+
+/**
+ * 把一个目录登记成工作区。
+ *
+ * 先 `resolveByPath` 再 `create`，虽然 `create` 自己也会复用同路径的已有记录
+ * （它的文档写着 "Repeated calls for the same canonical path return the existing
+ * entity without changing its title"）。多问一次是为了**能如实告诉手机
+ * 「这是新建的，还是本来就有」**——用户点了「新建工作区」，结果只是切到一个
+ * 早就登记过的目录，界面得说清楚，不能让他以为建了个新的。
+ *
+ * 两个方法的失败形状不一样，都要接：
+ *   - `resolveByPath` 在路径**不存在**时靠 realpath 抛错（文档原话：
+ *     "A missing path rejects during realpath"）
+ *   - `create` 在路径是相对路径、不存在、或者不是目录时拒绝
+ *
+ * 注意 `create` 会把路径用 `fs.realpath` 规范化——所以我们报回去的 `path`
+ * 用它给的那份，而不是手机传进来的那份。两者可能不一样（短路径、大小写、
+ * 符号链接），界面上要显示的是**真实的那条**。
+ */
+export async function createWorkspaceAt({ registry, path }) {
+  if (!registry || typeof registry.create !== 'function') {
+    return { ok: false, reason: 'no-registry' }
+  }
+  if (typeof path !== 'string' || path.trim() === '') {
+    return { ok: false, reason: 'bad-path' }
+  }
+
+  try {
+    const existing = await registry.resolveByPath(path)
+    if (existing) {
+      return { ok: true, created: false, workspace: shapeWorkspace(existing) }
+    }
+  } catch (err) {
+    // 路径不存在时这里就会抛。**不当作失败**：让它落到下面 create 那一步，
+    // 由 create 给出「不存在 / 不是目录」的准确说法。两处各报一次错的话，
+    // 手机上会看到两条不一样的话，反而不知道信哪条。
+  }
+
+  try {
+    const created = await registry.create(path)
+    return { ok: true, created: true, workspace: shapeWorkspace(created) }
+  } catch (err) {
+    return { ok: false, reason: 'failed', error: String(err?.message ?? err) }
+  }
+}
+
+/** 工作区实体 → 手机要的那几项。别把整个实体丢过去：它带一堆内部字段。 */
+function shapeWorkspace(ws) {
+  return {
+    id: ws?.id ?? '',
+    path: ws?.path ?? '',
+    title: (ws?.title || '').trim() || basename(ws?.path || '') || '未命名工作区',
+  }
+}
+
 /**
  * 某个工作区下的会话，新的在前，最多 limit 条。
  *
@@ -183,3 +289,39 @@ export async function listSessionsOf({ registry, query, agents, knownTitles, wor
     }),
   }
 }
+
+/**
+ * 会话日志的压缩体积（字节）。拿不到就返回 null——**不猜**。
+ *
+ * 为什么要它：`sessionQuery.readSession()` 会把整份事件解出来（还要做两次全量克隆），
+ * 而且 0.1.7-rc.2 起 v3 日志要走 v3→v4 迁移，迁移过程会把这个父会话的
+ * **每个直接子会话整份解码**。实测：26MB / 2.2 万事件的父会话带 310 个子会话时，
+ * 默认约 4GB 堆 20 秒就 OOM（见 2026-09-25 事故）。所以读之前先量体积。
+ */
+function logBytes(sessionId) {
+  const file = findSessionLog(sessionId)
+  if (!file) return null
+  try {
+    return statSync(file).size
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 一次「整份读」值不值得。子会话数用已缓存的 `listSessions()` 记录算（**无额外扫盘**）。
+ *
+ * 读不动有两类原因：① **子会话太多**（迁移要把它们全解出来）；② **自己太大**
+ * （解 + 两次克隆 ≈ 体积的 5–8 倍）。两个信号都给出去，阈值由调用方定。
+ *
+ * @param {{query:object, sessionId:string}} args
+ * @returns {Promise<{children:number, bytes:number|null}>} children = 以它为 parentSession 的会话数
+ */
+export async function sessionScale({ query, sessionId }) {
+  const records = await safeRecords(query)
+  let children = 0
+  for (const r of records) {
+    if (r?.header?.parentSession === sessionId) children += 1
+  }
+  return { children, bytes: logBytes(sessionId) }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mini-remote",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "DSH 极简移动端遥控器：只把「你的指令」和「AI 的最终回复」送到手机，屏蔽全部中间过程。",
   "type": "module",
   "main": "lib/index.js",
@@ -13,17 +13,18 @@
   },
   "files": [
     "lib",
-    "client",
+    "client/client.js",
     "cordis.patch.yml",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test test/smoke.test.mjs test/plugin.test.mjs test/net.test.mjs test/tunnel.test.mjs test/page.test.mjs test/tree.test.mjs"
+    "test": "node --test \"test/*.test.mjs\""
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=22",
+    "dsh": ">=0.1.5-rc.2"
   },
   "author": "xingzhen199186",
   "repository": {
@@ -52,7 +53,7 @@
   ],
   "license": "MIT",
   "disclosure": {
-    "transport": "手机与电脑之间是明文 http（内网 / Tailscale / Cloudflare 隧道三种任选其一）。访问口令随 URL 传递，所以公网隧道那条路请不要在不可信网络里用。",
+    "transport": "手机与电脑之间走 http 还是 https，取决于你选哪条路：内网是明文 http；Tailscale 默认也是明文 http，可以另开一个加密的 https 地址；Cloudflare 公网隧道是 https。访问口令随 URL 传递，所以公网隧道那条路请不要在不可信网络里用。",
     "storage": "不保存对话内容之外的任何凭据。cloudflared 二进制按需下载到 DSH 数据目录，不上传。",
     "telemetry": "不收集、不上传任何数据。",
     "network": "启用公网隧道时，流量经 Cloudflare 中转；内网和 Tailscale 两条路不经过任何第三方。"

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