dsh-mobile-plugin 0.1.100 → 0.2.0

package/lib/sidecar-facade-worker.cjs

@@ -26,6 +26,11 @@ const { lanUrls } = require('./relay/lan-network.cjs')
 const core = require('./relay/core.js')
 const { createReconnectScheduler } = require('./reconnect-scheduler.cjs')
 const { isMirrorSnapshotFresh } = require('./mirror-snapshot.cjs')
+// 凭据库在这个进程里**只读**（§3.7）：写盘只有宿主主进程一家。签发与吊销都经 IPC 交给它，
+// 本地这份按文件指纹重载 —— 两个进程各持一份内存副本、各自整份覆写，后写的赢，于是
+// 「经中转配上的手机回局域网 401」「吊销被回滚」这两条必然出现。
+const credentials = require('./shared/credentials-entry.js').credentialsEntry()
+if (typeof credentials.setReadOnly === 'function') credentials.setReadOnly(true)
 
 const parentPort = Number(process.env.DSH_SIDECAR_PARENT_PORT)
 const token = process.env.DSH_SIDECAR_TOKEN
@@ -104,6 +109,28 @@ class BodyTooLarge extends Error {}
  * 留 64KB 余量给帧头。推得再大也只是这一次 413，隧道安然无恙。
  */
 const TUNNEL_SEND_MAX_BODY = 8 * 1024 * 1024 - 64 * 1024
+
+/**
+ * 推给中转的那一份镜像：只留中转真的会读的字段。
+ *
+ * 桌面推上来的整份载荷里有四块：`sessions`、`workspaces`、`messages`、`stats`/`models`。
+ * 中转（`server/relay/rust/src/mirror.rs` 的 `remember`）只落**前两块**，另外三块
+ * 解析完就丢——它只解决「宿主不在线时手机还看得见清单」，会话正文有自己那条
+ * `/session/messages` 通道。而正文快照恰好是最大的一块：实测一个 200 条消息的会话
+ * 快照约 58KB，而它在每个会话事件上都会被重推一次。
+ *
+ * 所以**上隧道的那一份裁掉三块，本地快照（localSnapshot）照旧留全份**——局域网直连的
+ * 手机走 `snapshotRead` 读的就是本地那份，裁了它等于把读取隔离一起砍掉。
+ *
+ * 裁字段而不是改推送策略：宿主那侧「推什么、什么时候推」一个字都不用改，两侧版本
+ * 不必同时上线（老 worker + 新宿主也照旧工作，只是白推；新 worker + 老宿主也照旧）。
+ */
+function frameForTunnel(body) {
+  if (!body || typeof body !== 'object') return { kind: 'raw', data: body }
+  if (body.kind !== 'sync') return body
+  const { messages, stats, models, ...rest } = body
+  return rest
+}
 // /configure 只送 relay.json 那几十个字段，给 64KB 绰绰有余；放宽只会让误用更难发现。
 const CONFIGURE_MAX_BODY = 64 * 1024
 function readBody(req, limit) {
@@ -146,6 +173,12 @@ function upstream() { return `http://127.0.0.1:${config.upstreamPort}` }
 // 读取隔离：把移动端高频读请求（sessions/workspaces/messages/stats）从本地快照直接回，
 // 不再打扰主进程。快照缺失或路径不在清单内时返回 null → 调用方回源主进程。
 function snapshotRead(info) {
+  // **协议 v2 的会话不走这条捷径**：这里直接回序列化好的 JSON，绕开了主进程的守卫 ——
+  // 请求信封没验、响应也没封。表现是「加密会话的高频读（列表 / 工作区 / 消息 / 统计）
+  // 全程明文过中转」，而且静默（App 收到明文只是降级，不报错）。回 null 让调用方回源
+  // 主进程，那条路有 `rev` 条件刷新，稳态只回几十字节，比这里回 38KB 还省。
+  const proto = info && info.headers ? String(info.headers['x-dsh-proto'] || info.headers['X-Dsh-Proto'] || '') : ''
+  if (proto.trim() === '2') return null
   // 镜像只在中转连着时才会有新版本推来（原因见 mirror-snapshot.cjs 的说明）：冻结的快照必须
   // 回源主进程，否则中转一断、局域网仍健康时，新建的会话/工作区在 App 里永远不出现。
   if (!isMirrorSnapshotFresh(localSnapshot)) return null
@@ -160,6 +193,16 @@ function snapshotRead(info) {
     : null
   if (!body || typeof body !== 'object' || body.ok !== true) return null
   if (pathname === '/api/mobile/v1/session/messages') {
+    // **按内容裁的入口窗口（`thin=1`）不走这条捷径**：镜像里存的是一份完整窗口
+    // （最多 200 条消息），对着一轮跑过上百步的会话，它照样可能整条挤掉用户那句话 ——
+    // 那正是「进对话只剩 AI 的半轮」这个缺陷本身。裁剪是主进程按轮算的，这里回 null 让它
+    // 回源；入口那一发进对话只发一次，不是轮询。
+    if (url.searchParams.get('thin') === '1') return null
+    // 带 beforeSeq 的是**翻页**（往上翻历史 / 补取某一轮的过程明细）：镜像只有尾部一份窗口，
+    // 它答不了「比这条更早」——早年这里直接回整份，调用方按 seq 自己过滤，看着能用，
+    // 但只要一轮比镜像窗口还长，补取就会在原地转三圈什么也拿不到。回源主进程。
+    const beforeSeqRaw = url.searchParams.get('beforeSeq')
+    if (beforeSeqRaw !== null && beforeSeqRaw !== '') return null
     const afterSeqRaw = url.searchParams.get('afterSeq')
     if (afterSeqRaw !== null && afterSeqRaw !== '' && /^\d+$/.test(afterSeqRaw)) {
       const after = Number(afterSeqRaw)
@@ -186,7 +229,9 @@ function tunnelSignature(c) {
 }
 /** 「这份配置里哪几项决定局域网代理要重建」。 */
 function lanSignature(c) {
-  return JSON.stringify([Boolean(c.enabled), Boolean(c.lanEnabled), c.lanPort || 0, c.upstreamPort || 0, c.instanceId || '', c.pairingCode || '', c.lanSecret || ''])
+  // **配对码与票据不在其中**：它们由 `currentPairing` 现读，改它们不该重建监听 ——
+  // 配对成功就要换一次（§5.1），跟着重建会把刚握上的连接掐掉。
+  return JSON.stringify([Boolean(c.enabled), Boolean(c.lanEnabled), c.lanPort || 0, c.upstreamPort || 0, c.instanceId || '', c.lanSecret || ''])
 }
 /** 「这份配置里哪几项决定网络监视器要不要重排」。 */
 function monitorSignature(c) {
@@ -237,7 +282,7 @@ function startTunnel() {
   stopTunnel(); tunnelState = 'connecting'
   publishState()
   const current = new RelayTunnel({
-    relayUrl: core.tunnelWsUrl(config.relayUrl), instanceId: config.instanceId, pairingCode: config.pairingCode,
+    relayUrl: core.tunnelWsUrl(config.relayUrl), instanceId: config.instanceId,
     name: config.name, upstream: upstream(),
     registerSecret: config.registerSecret,
     lanUrls: currentLanUrls(),
@@ -275,10 +320,22 @@ function startLan() {
   stopLan(); lanState = 'connecting'
   publishState()
   const current = createLanProxy({
-    lanPort: config.lanPort, pairingCode: config.pairingCode, instanceId: config.instanceId, lanSecret: config.lanSecret,
+    lanPort: config.lanPort, instanceId: config.instanceId, lanSecret: config.lanSecret,
+    // 配对码与票据走取值器：配对成功之后宿主会换掉它们（§5.1），而重建局域网代理会把
+    // 刚握上的连接全掐掉 —— 换值不该动监听。
+    currentPairing: () => ({ code: config.pairingCode, ticket: config.pairingTicket || '' }),
     upstreamPort: config.upstreamPort,
     readSnapshot: snapshotRead,
     onLog: (...args) => process.stderr.write(`[dsh-ai-hub sidecar] ${args.join(' ')}\n`),
+    // 配对成功之后换码 + 换票据：走宿主的控制面（那是唯一能写状态文件的地方）。
+    onPaired: () => {
+      void parentJson('/api/relay/internal/rotate-pairing', {}).catch(() => undefined)
+    },
+    // 签发交给主进程（唯一写方）：旁路自己写盘会和主进程那份互相覆盖。
+    issueCredential: async (device, extra) => {
+      const result = await parentJson('/api/relay/internal/issue-credential', { device: device || {}, extra: extra || {} })
+      return result.data || result
+    },
     onApprove: async (device) => {
       try {
         const result = await parentJson('/api/relay/internal/approval', { device: device || {} })
@@ -306,10 +363,11 @@ function startLan() {
 }
 async function configure(next) {
   if (!next || typeof next !== 'object' || Array.isArray(next)) throw new Error('invalid configuration')
-  const allowed = ['enabled', 'relayUrl', 'instanceId', 'pairingCode', 'name', 'upstreamPort', 'lanPort', 'lanEnabled', 'lanSecret', 'registerSecret']
+  const allowed = ['enabled', 'relayUrl', 'instanceId', 'pairingCode', 'pairingTicket', 'name', 'upstreamPort', 'lanPort', 'lanEnabled', 'lanSecret', 'registerSecret']
   if (Object.keys(next).some(key => !allowed.includes(key))) throw new Error('unknown configuration field')
   if (typeof next.instanceId !== 'string' || next.instanceId.length > 128) throw new Error('invalid instanceId')
   if (typeof next.pairingCode !== 'string' || !/^\d{6}$/.test(next.pairingCode)) throw new Error('invalid pairingCode')
+  if (next.pairingTicket !== undefined && (typeof next.pairingTicket !== 'string' || !/^[A-Za-z0-9_-]{0,64}$/.test(next.pairingTicket))) throw new Error('invalid pairingTicket')
   if (typeof next.upstreamPort !== 'number' || !Number.isInteger(next.upstreamPort) || next.upstreamPort < 1 || next.upstreamPort > 65535) throw new Error('invalid upstreamPort')
   if (next.lanPort !== undefined && (!Number.isInteger(next.lanPort) || next.lanPort < 1024 || next.lanPort > 65535)) throw new Error('invalid lanPort')
   if (next.registerSecret !== undefined && (typeof next.registerSecret !== 'string' || next.registerSecret.length > 512)) throw new Error('invalid registerSecret')
@@ -333,7 +391,8 @@ async function configure(next) {
   }
   if (!tunnelNeedsRebuild && tunnel) {
     const patch = {}
-    if (previous.pairingCode !== config.pairingCode) patch.pairingCode = config.pairingCode
+    // **配对码不再进注册帧**（§5.2）：中转从来没读过它（`ws.rs` 原文「不保存也不校验」），
+    // 而带上它就等于把「谁能配这台机器」的一半凭证交给链路上的第三方。
     if (previous.name !== config.name) patch.name = config.name
     if (lanNeedsRebuild) patch.lanUrls = currentLanUrls()
     if (Object.keys(patch).length) tunnel.updateRegistration(patch)
@@ -365,7 +424,12 @@ const server = http.createServer(async (req, res) => {
       // 桌面→relay 主动推送（移动端镜像缓存）：复用隧道立即 sendJson；同时在本地保留快照供读取隔离。
       if (body && typeof body === 'object' && body.kind === 'sync') localSnapshot = body;
       if (tunnel && tunnel.connected) {
-        tunnel.sendJson(T.sync, 0, body && typeof body === 'object' ? body : { kind: 'raw', data: body });
+        // kind === 'push' 是 iOS 推送帧（pushRegister / pushSend），帧类型由 pushFrame
+        // 决定，不再一律塞进 sync——中转按帧类型分发，塞错类型等于发到黑洞。
+        const frameType = body && typeof body === 'object' && body.kind === 'push'
+          ? (body.pushFrame === 'register' ? T.pushRegister : T.pushSend)
+          : T.sync;
+        tunnel.sendJson(frameType, 0, frameForTunnel(body));
         return send(res, 202, { ok: true });
       }
       return send(res, 503, { ok: false, error: 'tunnel not connected' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.100",
+  "version": "0.2.0",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (0.2.0-rc.2 compatible, peers resolved by the host)",
   "license": "MIT",
   "type": "module",
@@ -42,7 +42,8 @@
   },
   "scripts": {
     "start": "node host.js",
-    "test": "node --test test/*.test.cjs && node test/lan-direct-e2e.cjs && node test/sidecar-facade.cjs"
+    "test": "node --test test/*.test.cjs && node test/lan-direct-e2e.cjs && node test/sidecar-facade.cjs",
+    "release:check": "node scripts/preflight-release.mjs"
   },
   "dependencies": {
     "@deepseek-ai/dsh-tool-ask-user": "0.2.1-rc.2",