dsh-plugin-mobile-gateway 0.7.6 → 0.7.7

package/PROTOCOL.md

@@ -174,6 +174,8 @@ func connectAuthenticated(publicURL: URL, token: String) -> URLSessionWebSocketT
 `subscribed` 之后，服务端会紧接着发送该 Session 尚未处理的
 `question-requested` / `approval-requested`，并标记 `replay: true`。客户端必须按
 `rpcId` 去重。这保证移动端在审批产生后才打开已有 Session 时仍能显示待处理卡片。
+启用 `split-channels` 时，`subscribe` 仍由 conversation 连接发送，但上述重放帧会
+桥接到 control 连接；交互卡片不得发送到 conversation 连接。
 
 ---
 
@@ -186,9 +188,16 @@ Human-in-the-loop 分为两条独立通道：
 
 二者都是 Host waterfall 的临时请求，不属于持久化的 `session/event`，且都必须以插件为该次请求生成的 `rpcId` 通过专用响应帧回答，不能作为普通 `message` 发送。该内部实现不改变移动端帧格式。
 
+同一请求遵循“任意端先完成、所有端同步收起”的单胜方规则：Mobile 任一设备先完成时，Gateway 会结束 Host 的 WebUI 远端请求并让所有 WebUI 实例收起；任一 WebUI 先完成时，Host 会取消其余 WebUI 实例，Gateway 同时向所有 Mobile 设备广播终态。迟到响应统一视为 `not-pending`。
+
 ### 3.1 提问与回答
 
-Agent 调用 DSH 的 `ask_user_question` 工具时，插件直接接入 Host 的 `user-questions/request` waterfall，并把临时请求投影给移动端。若没有可处理该 Session 的移动连接，插件调用 `next()`，由 WebUI 或后续 Host answerer 处理。
+Agent 调用 DSH 的 `ask_user_question` 工具时，插件接入 Host 的
+`user-questions/request` waterfall，把临时请求投影给移动端，同时继续启动 WebUI
+或后续 Host answerer。任一端先给出有效答案即完成该请求；Gateway 会向所有移动端
+广播 `question-resolved`。Mobile 先完成时，Gateway 同时取消 WebUI 的对应远端请求，
+使其收起半屏弹窗；WebUI 先完成时，移动端收到终态后收起对应卡片。若 Mobile 已断开，
+则由仍在等待的 Host answerer 继续处理。
 
 #### `question-requested` — 服务端推送问题
 
@@ -292,7 +301,12 @@ Agent 调用 DSH 的 `ask_user_question` 工具时，插件直接接入 Host 的
 
 ### 3.2 操作审批
 
-当 DSH 的工具管线要求人工授权时，插件会接入一次 Host `approval/request` waterfall，并向移动端投影为 `approval-requested`。这正是 Web UI 中“等待审批”卡片对应的能力：`reason` 是面向用户的审批说明，`toolName` 标识请求操作的工具，`callId` 可用于与实时工具调用轨迹关联。
+当 DSH 的工具管线要求人工授权时，插件会接入一次 Host `approval/request`
+waterfall，并向移动端投影为 `approval-requested`，同时保留 WebUI answerer；WebUI
+与 Mobile 中任一端先提交的有效决定生效。Gateway 随后向所有移动端广播
+`approval-resolved`；若 Mobile 先完成，还会取消 WebUI 的对应远端请求以收起审批弹窗。
+`reason` 是面向用户的审批说明，`toolName` 标识请求操作的工具，`callId` 可用于与实时
+工具调用轨迹关联。
 
 #### `approval-requested` — 服务端推送待审批操作
 

package/lib/index.mjs

@@ -2245,20 +2245,43 @@ const plugin = {
     }
 
     const replayPendingInteractions = (ws, trigger) => {
-      if (ws.mobileChannel === 'conversation') return { questionCount: 0, approvalCount: 0 }
+      // In split-channel mode `subscribe` belongs to the conversation socket,
+      // while interaction frames belong to the control socket. Bridge a
+      // conversation subscription to every live control/legacy socket so
+      // reopening a Session restores its still-pending cards. Reducers dedupe
+      // by rpcId, so replaying to another trusted device is harmless and keeps
+      // all active clients in sync.
+      // The companion control socket already receives a full replay when it
+      // connects, so a bare conversation connect must not duplicate it again.
+      if (ws.mobileChannel === 'conversation' && trigger !== 'subscribe') {
+        return { questionCount: 0, approvalCount: 0 }
+      }
+      const recipients = ws.mobileChannel === 'conversation'
+        ? [...clients].filter((client) => client.readyState === 1 && client.mobileChannel !== 'conversation')
+        : [ws]
+      if (recipients.length === 0) return { questionCount: 0, approvalCount: 0 }
+      const sessionId = ws.filterSessionId
       let questionCount = 0
       let approvalCount = 0
       for (const pending of pendingQuestions.values()) {
-        if (ws.filterSessionId && ws.filterSessionId !== pending.sessionId) continue
-        ws.send(stringifyWireFrame(questionFrameFor(pending.rpcId, pending, true)))
+        if (sessionId && sessionId !== pending.sessionId) continue
+        const wire = stringifyWireFrame(questionFrameFor(pending.rpcId, pending, true))
+        for (const recipient of recipients) {
+          if (recipient.filterSessionId && recipient.filterSessionId !== pending.sessionId) continue
+          recipient.send(wire)
+        }
         questionCount += 1
       }
       for (const pending of pendingApprovals.values()) {
-        if (ws.filterSessionId && ws.filterSessionId !== pending.sessionId) continue
-        ws.send(stringifyWireFrame(approvalFrameFor(pending.rpcId, pending, true)))
+        if (sessionId && sessionId !== pending.sessionId) continue
+        const wire = stringifyWireFrame(approvalFrameFor(pending.rpcId, pending, true))
+        for (const recipient of recipients) {
+          if (recipient.filterSessionId && recipient.filterSessionId !== pending.sessionId) continue
+          recipient.send(wire)
+        }
         approvalCount += 1
       }
-      log(`interaction replay: trigger=${trigger} filtered=${Boolean(ws.filterSessionId)} questions=${questionCount} approvals=${approvalCount}`)
+      log(`interaction replay: trigger=${trigger} channel=${ws.mobileChannel} filtered=${Boolean(sessionId)} recipients=${recipients.length} questions=${questionCount} approvals=${approvalCount}`)
       return { questionCount, approvalCount }
     }
 
@@ -2268,15 +2291,24 @@ const plugin = {
       && (!client.filterSessionId || client.filterSessionId === sessionId)
     ))
 
-    const completeQuestion = (pending, action, answer, cancellationCode = 'ASK_CANCELLED') => {
+    const abortDownstreamInteraction = (pending, kind) => {
+      if (pending.downstreamAbort.signal.aborted) return
+      // The Host API gateway fans this abort out to every WebUI delivery of
+      // the same Remote event. Its existing cancel handling removes each
+      // pending BottomSheet; Mobile peers receive the resolved frame below.
+      pending.downstreamAbort.abort(new Error(`${kind} completed outside WebUI`))
+    }
+
+    const completeQuestion = (pending, action, answer, cancellationCode = 'ASK_CANCELLED', cancellationError, source = 'mobile') => {
       if (pendingQuestions.get(pending.rpcId) !== pending) return false
       pendingQuestions.delete(pending.rpcId)
       pending.cleanup()
+      if (source !== 'downstream') abortDownstreamInteraction(pending, 'question')
       if (action === 'answer') pending.resolve(answer)
       else {
-        const error = new Error('question cancelled by mobile user')
-        error.name = 'UserQuestionError'
-        error.code = cancellationCode
+        const error = cancellationError ?? new Error('question cancelled by mobile user')
+        if (!error.name || error.name === 'Error') error.name = 'UserQuestionError'
+        if (!error.code) error.code = cancellationCode
         pending.reject(error)
       }
       broadcastInteractionFrame({
@@ -2315,10 +2347,11 @@ const plugin = {
       return { value: { answers: normalized } }
     }
 
-    const completeApproval = (pending, outcome) => {
+    const completeApproval = (pending, outcome, source = 'mobile') => {
       if (pendingApprovals.get(pending.rpcId) !== pending) return false
       pendingApprovals.delete(pending.rpcId)
       pending.cleanup()
+      if (source !== 'downstream') abortDownstreamInteraction(pending, 'approval')
       pending.resolve(outcome)
       broadcastInteractionFrame({
         kind: 'approval-resolved',
@@ -2330,18 +2363,80 @@ const plugin = {
       return true
     }
 
+    const startDownstreamQuestion = (pending) => {
+      let downstream
+      try {
+        downstream = pending.next()
+      } catch (error) {
+        pending.downstream = { kind: 'rejected', error }
+        return
+      }
+      pending.downstream = { kind: 'pending' }
+      Promise.resolve(downstream).then((answer) => {
+        if (pendingQuestions.get(pending.rpcId) !== pending) return
+        if (answer && Array.isArray(answer.answers)) {
+          completeQuestion(pending, 'answer', answer, undefined, undefined, 'downstream')
+          log(`question resolved by downstream answerer: rpcId=${pending.rpcId} session=${pending.sessionId}`)
+        } else {
+          // A downstream answerer may report that no WebUI currently owns the
+          // request. Keep Mobile active; the value is used only if every Mobile
+          // client later disconnects.
+          pending.downstream = { kind: 'unavailable', value: answer }
+          if (!hasInteractionClient(pending.sessionId)) fallbackQuestion(pending)
+        }
+      }, (error) => {
+        if (pendingQuestions.get(pending.rpcId) !== pending) return
+        if (error?.code === 'ASK_CANCELLED' || error?.code === 'ASK_ABORTED') {
+          completeQuestion(pending, 'cancel', undefined, error.code, error, 'downstream')
+          log(`question cancelled by downstream answerer: rpcId=${pending.rpcId} session=${pending.sessionId}`)
+        } else {
+          pending.downstream = { kind: 'rejected', error }
+          if (!hasInteractionClient(pending.sessionId)) fallbackQuestion(pending)
+        }
+      })
+    }
+
+    const startDownstreamApproval = (pending) => {
+      let downstream
+      try {
+        downstream = pending.next()
+      } catch (error) {
+        pending.downstream = { kind: 'rejected', error }
+        return
+      }
+      pending.downstream = { kind: 'pending' }
+      Promise.resolve(downstream).then((outcome) => {
+        if (pendingApprovals.get(pending.rpcId) !== pending) return
+        if (outcome === 'allowed-once' || outcome === 'rejected') {
+          completeApproval(pending, outcome, 'downstream')
+          log(`approval resolved by downstream answerer: rpcId=${pending.rpcId} session=${pending.sessionId} outcome=${outcome}`)
+        } else {
+          pending.downstream = { kind: 'unavailable', value: outcome }
+          if (!hasInteractionClient(pending.sessionId)) fallbackApproval(pending)
+        }
+      }, (error) => {
+        if (pendingApprovals.get(pending.rpcId) !== pending) return
+        pending.downstream = { kind: 'rejected', error }
+        if (!hasInteractionClient(pending.sessionId)) fallbackApproval(pending)
+      })
+    }
+
     const fallbackQuestion = (pending) => {
       if (pendingQuestions.get(pending.rpcId) !== pending) return
+      if (pending.downstream?.kind === 'pending') return
       pendingQuestions.delete(pending.rpcId)
       pending.cleanup()
-      Promise.resolve().then(pending.next).then(pending.resolve, pending.reject)
+      if (pending.downstream?.kind === 'rejected') pending.reject(pending.downstream.error)
+      else pending.resolve(pending.downstream?.value)
     }
 
     const fallbackApproval = (pending) => {
       if (pendingApprovals.get(pending.rpcId) !== pending) return
+      if (pending.downstream?.kind === 'pending') return
       pendingApprovals.delete(pending.rpcId)
       pending.cleanup()
-      Promise.resolve().then(pending.next).then(pending.resolve, pending.reject)
+      if (pending.downstream?.kind === 'rejected') pending.reject(pending.downstream.error)
+      else pending.resolve(pending.downstream?.value)
     }
 
     const releaseUnclaimedInteractions = () => {
@@ -2857,22 +2952,29 @@ const plugin = {
       if (!sessionId || !Array.isArray(request.questions) || !hasInteractionClient(sessionId)) return next()
       const rpcId = crypto.randomUUID()
       return new Promise((resolve, reject) => {
+        const requestSignal = request.signal
+        const downstreamAbort = new AbortController()
+        request.signal = requestSignal
+          ? AbortSignal.any([requestSignal, downstreamAbort.signal])
+          : downstreamAbort.signal
         const onAbort = () => {
           const pending = pendingQuestions.get(rpcId)
           if (pending) completeQuestion(pending, 'cancel', undefined, 'ASK_ABORTED')
         }
-        request.signal?.addEventListener('abort', onAbort, { once: true })
+        requestSignal?.addEventListener('abort', onAbort, { once: true })
         const pending = {
           rpcId,
           sessionId,
           questions: request.questions,
           next,
+          downstreamAbort,
           resolve,
           reject,
-          cleanup: () => request.signal?.removeEventListener('abort', onAbort),
+          cleanup: () => requestSignal?.removeEventListener('abort', onAbort),
         }
         pendingQuestions.set(rpcId, pending)
         broadcastInteractionFrame(questionFrameFor(rpcId, pending))
+        startDownstreamQuestion(pending)
         log(`question requested: rpcId=${rpcId} session=${sessionId} questions=${request.questions.length}`)
       })
     }, { prepend: true })
@@ -2883,11 +2985,16 @@ const plugin = {
       const rpcId = crypto.randomUUID()
       const approvalId = crypto.randomUUID()
       return new Promise((resolve, reject) => {
+        const requestSignal = request.signal
+        const downstreamAbort = new AbortController()
+        request.signal = requestSignal
+          ? AbortSignal.any([requestSignal, downstreamAbort.signal])
+          : downstreamAbort.signal
         const onAbort = () => {
           const pending = pendingApprovals.get(rpcId)
           if (pending) completeApproval(pending, 'cancelled')
         }
-        request.signal?.addEventListener('abort', onAbort, { once: true })
+        requestSignal?.addEventListener('abort', onAbort, { once: true })
         const pending = {
           rpcId,
           sessionId,
@@ -2896,12 +3003,14 @@ const plugin = {
           ...(request.callId !== undefined ? { callId: request.callId } : {}),
           ...(request.reason !== undefined ? { reason: request.reason } : {}),
           next,
+          downstreamAbort,
           resolve,
           reject,
-          cleanup: () => request.signal?.removeEventListener('abort', onAbort),
+          cleanup: () => requestSignal?.removeEventListener('abort', onAbort),
         }
         pendingApprovals.set(rpcId, pending)
         broadcastInteractionFrame(approvalFrameFor(rpcId, pending))
+        startDownstreamApproval(pending)
         log(`approval requested: rpcId=${rpcId} approvalId=${approvalId} session=${sessionId} tool=${request.toolName}`)
       })
     }, { prepend: true })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-mobile-gateway",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Mobile gateway for dsh 0.1.5-rc.1/2 with per-session Agent preset selection before the first conversation, automatic preset locking after conversation starts, and live preset updates",
   "main": "lib/index.mjs",
   "files": [