dsh-mini-remote 0.1.0 → 0.1.4

package/lib/store.js

@@ -33,6 +33,14 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
      * 任何一条广播都能把它补上。
      */
     liveBySession: {},
+    /**
+     * 模型此刻的「自言自语」：sessionId -> { text, at }。**同样故意不落盘**。
+     *
+     * 只给手机上的鲸鱼娘当台词用，和 latest/history 完全分开——它既不是回答，
+     * 也不是历史的一部分（历史有 50 条上限，思考会把它挤爆）。一轮结束就清掉，
+     * 所以刷新页面看到的是「当前这一句」，而不是上一次的残留。
+     */
+    thoughtBySession: {},
   }
 
   /** 已知会话的元信息：sessionId -> { id, title, running, lastActivity, seq } */
@@ -84,6 +92,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
@@ -105,6 +178,18 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
     return sessionId ? (state.liveBySession[sessionId] ?? '') : ''
   }
 
+  /**
+   * 模型此刻的自言自语（鲸鱼娘的台词）。
+   *
+   * 和 live 分开存，**不是为了整齐**：页面上的鲸鱼娘只要发现 live 非空就会整块让位
+   * （那是「正在流出来的回答」的规矩），把思考塞进 live 会让该出现台词的时候鲸鱼娘
+   * 直接消失。
+   */
+  function thoughtOf(sessionId) {
+    const t = sessionId ? state.thoughtBySession[sessionId] : null
+    return t ? { text: t.text, at: t.at } : null
+  }
+
   /**
    * 只保留最近碰过的若干会话的数据，免得这个 JSON 文件无限长大。
    * 被丢掉的会话切过去会显示「还没有回复」——**这比显示别人的回答强**。
@@ -117,6 +202,7 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
       delete state.historyBySession[id]
       delete state.latestBySession[id]
       delete state.liveBySession[id]
+      delete state.thoughtBySession[id]
     }
   }
 
@@ -214,6 +300,9 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
     /** 告诉 store「队列里有什么」该去哪儿问（见 setQueueSource）。 */
     setQueueSource,
 
+    /** 告诉 store「这个会话完整的历史」该去哪儿问（见 setReplaySource）。 */
+    setReplaySource,
+
     /** 某个会话的最新回复 / 聊天记录。 */
     latestOf,
     historyOf,
@@ -229,27 +318,76 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
      * interrupted 是「这一轮被中止了，下面只是已经吐出来的那半句」。
      * 手机要把它标出来——不标的话，按了停止之后冒出来的半句话看着像模型答崩了。
      */
-    pushReply({ text, sessionId, reason, interrupted }) {
-      const timestamp = Date.now()
+    pushReply({ text, sessionId, reason, interrupted, timestamp }) {
+      // 同上：事件带过来的 `time` 优先。合成时两边的钟不一样，同一条回复就会
+      // 既从硬盘来一遍、又从手里这份来一遍，手机上显示两遍。
+      const at = timestamp ?? Date.now()
       const session = sessions.get(sessionId)
       state.latestBySession[sessionId] = {
-        text, sessionId, title: session?.title ?? '', timestamp, reason,
+        text, sessionId, title: session?.title ?? '', timestamp: at, reason,
         interrupted: interrupted === true,
       }
       pushHistory(sessionId, {
-        role: 'assistant', text, timestamp, sessionId, interrupted: interrupted === true,
+        role: 'assistant', text, timestamp: at, sessionId, interrupted: interrupted === true,
       })
       persist()
     },
 
     /** 用户（手机上或电脑上）发出了一条指令。 */
-    pushUser({ text, sessionId, id }) {
+    pushUser({ text, sessionId, id, timestamp }) {
       // id 要留着：排队中的指令靠它和 agent 收件箱里的那一条对上号，
       // 界面上才能标出「这条还在排队」、也才能撤掉它。
-      pushHistory(sessionId, { role: 'user', text, timestamp: Date.now(), sessionId, id })
+      //
+      // 时间戳要是有事件带过来的那个 `time`，就用它，别用 Date.now()——理由和
+      // pushCommand 那段一模一样：这一条要和硬盘重放出来的那份按时间戳合成，
+      // **两边得是同一个钟**。差一毫秒就够它被当成「新的一条」再接一遍，手机上
+      // 同一条指令显示两遍（2026-09-27 用户实机报的，实测两份差 1 毫秒）。
+      pushHistory(sessionId, {
+        role: 'user', text, timestamp: timestamp ?? Date.now(), sessionId, id,
+      })
       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
+        }
+      }
+    },
+
     /**
      * 清空**当前会话**在单帧模式里的内容。
      *
@@ -281,6 +419,20 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
       else delete state.liveBySession[sessionId]
     },
 
+    /**
+     * 记下模型此刻的自言自语，给鲸鱼娘当台词。传 null 就是「没话说了」，清掉。
+     *
+     * 同样不 persist()：它活不过一轮，写盘只会留下一句没头没尾的旧台词。
+     */
+    setThought(sessionId, thought) {
+      if (!sessionId) return
+      if (thought && thought.text) {
+        state.thoughtBySession[sessionId] = { text: thought.text, at: thought.at ?? Date.now() }
+      } else {
+        delete state.thoughtBySession[sessionId]
+      }
+    },
+
     /** 手机是否真的在看着——决定要不要额外发系统推送。 */
     isForeground() {
       return state.presence === 'foreground' && Date.now() - state.lastSeen < 60_000
@@ -288,15 +440,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: latestOf(target),
-        history: historyOf(target),
+        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 / 尾部窗口）：会话太大时
+         * 只读日志尾部。**必须跟着内容一起说出去**——否则用户会以为这个会话就这么点。
+         */
+        historyTruncated: replay?.truncated === true,
+        /** 给手机的一句人话（为什么不是全部）；null = 不用解释。 */
+        historyNote: replay?.note ?? null,
         /**
          * 正在流出来的那一段（可能为空）。
          *
@@ -304,6 +480,13 @@ export function createStore({ file, maxHistory = 50, maxSessions = 12 }) {
          * 当成答案——真正的答案还是要等不含工具调用的那一步落定（见 events.js）。
          */
         live: liveOf(target),
+        /**
+         * 模型此刻的自言自语（鲸鱼娘的气泡台词），没有就是 null。
+         *
+         * **第三次重申它的边界**：这不是回答、不进历史、不参与「有没有新回复」的
+         * 判断。哪怕它错乱到显示了上一句，代价也只是气泡里一句话旧了。
+         */
+        thought: thoughtOf(target),
         boundSessionId: state.boundSessionId,
         /**
          * 「正在执行」必须跟着会话走。

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.4",
   "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": {
@@ -35,13 +36,21 @@
     "url": "https://github.com/xingzhen199186/dsh-mini-remote/issues"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.2"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh": ">=0.1.5-rc.2 <0.2.0",
+    "@deepseek-ai/schemastery": "^3.18.3"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {
       "optional": true
+    },
+    "@deepseek-ai/dsh": {
+      "optional": true
     }
   },
+  "devDependencies": {
+    "@deepseek-ai/schemastery": "^3.18.3"
+  },
   "keywords": [
     "deepseek-harness",
     "dsh",
@@ -52,7 +61,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 两条路不经过任何第三方。"