dsh-sidecard-ask 2.1.3 → 2.1.4

package/CHANGELOG.md

@@ -1,5 +1,59 @@
 # Changelog
 
+## 2.1.4
+
+**主题：把「技术方案评审团」查出的 11 条缺陷一次修完。四套脚本全绿，新增 21 条回归断言。**
+排查依据：Software Architect / Application Security Engineer / Reality Checker 三方评审 + 源码复核 + 实测复现。
+
+### 修复
+
+- **B1（阻断，静默数据丢失）关闭的卡片在下次答题完成时被抹掉**。`syncPersisted()` 只从
+  「活跃卡片」重建整个持久化集合再整键覆盖，而 `close()` 只把卡片移出活跃区、durable 快照
+  仍留在 `store.state.history` 里，于是关掉的那张被静默删除（`contract-test` 原先把破坏后的
+  结果当成了期望值）。现在写的是并集：活跃卡片 ∪ 尚未关闭的历史条目，按 id 去重（活跃方
+  优先）后按 newest-first 截到 cap。删除路径本来就先改 `store.history` 再写盘，并集不会把
+  它们删掉的条目复活。
+- **B2（高，虚假安全保证）`agentPreset` 在 0.2.1-alpha.2+ 的 activation 面没被转发**。
+  `startSubagent` 只在旧 `start(provider, request)` 面转发 `agentPreset`，新面的 `request`
+  漏了它 → 子代理拿默认全套工具，而 start 帧仍按配置上报 `toolFilter: 'preset'`，卡片于是
+  对用户谎报「工具集由 preset 决定」。现在两个面都转发。
+- **B3（中高，降级链断裂）Rung 1 `sessions.using()` 没有 try/catch**。它一抛（会话归档、
+  形状漂移，或它内部的 `no-session-face`），整条「改发到主对话」就断在第一档，后面
+  `retain` / `inputActions` / `draft` 三档全部不可达。现在与 Rung 2 对称降级，
+  `prompt-rejected` 仍照旧抛给调用方（那是用户可见的拒绝，不是通道缺失）。
+- **B4（中，原生栏串卡）第二张卡开进原生右栏时第一张没有迁回浮层**。它只是被盖住——卡片
+  仍标 `native-rightbar`、store 里被过滤掉，流式输出继续往看不见的卡片里写，且 rail 上那张
+  永远关不掉。现在 `open()` 先把栏里其它卡片迁回 `flow`；`close()` 增加归属校验（栏被另一
+  张卡占用时不替它关）与 `contentId` 行匹配（多行时关「属于这张卡」的那行）；`openTab`
+  抛错时回滚 `cardId`，避免 CardHost 去渲染一张根本没有 tab 的卡。
+- **B5（中低）`/cancel` 把跨会话的全局 run id 列表回给页面**。`runs` 是跨会话的全局表，
+  回 `active` 等于泄露别的会话正在追问的卡片 id（`cancel` 本身也不校验归属），而 Client
+  从不消费它。现在只回 `{ cancelled }`。
+- **B6（中低，迁移被永久挡住）空的 v3 信封会阻断 v1/v2 迁移**。`raw !== null` 就直接
+  return，损坏的 JSON 或旧版本留下的空信封同样挡住。现在写盘时带 `writtenAt` 标记，只有
+  「本版本自己写的空信封」才算权威（用户确实清空了历史，绝不从 v2/v1 复活），没有该标记的
+  空信封与损坏 JSON 继续向下探测。
+- **B7（低，卸载泄漏）`dispose()` 只清了 `streamListeners`，漏了 `chunkListeners`**。第二个
+  流来源的订阅者会留下仍被 `session/event` 桥持有的闭包（它捕获整个 engine 状态）。
+- **B9（低，死重量）持久化写死 `slice(-12)`，而 `followUp` 只发 6 轮**。改成
+  `HISTORY_TURNS`，与上下文预算同一个上限。
+- **B10（低，死代码）`let finished = false` 只赋值不读取**，删除。
+- **B11（低，可诊断性）信任围栏的 403 只说 `forbidden`**。现在说明「Host 不在信任范围 +
+  怎么放行（127.0.0.1 或 `trustedHosts`）」。有意**不**自动信任绑定地址：插件读不到宿主的
+  bind 配置，猜一个就等于自己拆掉 DNS-rebinding 防线。
+- **B8（条件性，平台限制）配置里的 SMTP 密码以明文落在 `~/.dsh/` 下的用户层 JSON**。
+  写盘已带 `mode: 0o600`（POSIX 生效，Windows 忽略），代码注释与 README 均已注明；
+  无进程内可做的进一步缓解，**保留为已文档化的限制**，建议优先用环境变量。
+
+### 验证
+
+`node test/verify.mjs` / `contract-test.mjs` / `float-placement.mjs` / `smoke-test.mjs`：
+**57 / 1446 / 100 / 277 全绿（1880 条，0 失败）**。相对修复前 1859 条新增 21 条回归断言，
+逐条对应上面的缺陷：关卡片后历史仍在（contract）、activation 面转发 preset 且无能力时
+不带该字段（smoke）、`using()` 抛错降级而 `prompt-rejected` 仍抛（contract）、空/损坏 v3
+信封不挡迁移且自有空信封不被复活（contract）、原生栏单地址与关 tab 归属（contract）、
+`/cancel` 不泄露 `active`（smoke）。
+
 ## 2.1.3
 
 **主题：折叠态胶囊不再压在聊天输入框上（2026-10-25 实拍报告）。**

package/client.js

@@ -117,7 +117,7 @@ window.__ModuleLoader__.load({
      * the Host and the module's `api.version` both read it, so a report can
      * never claim a generation the browser is not actually running.
      */
-    const CLIENT_VERSION = '2.1.3'
+    const CLIENT_VERSION = '2.1.4'
 
     /**
      * Tab kind served by the DSH native right rail (also its implementation id).
@@ -2178,16 +2178,26 @@ window.__ModuleLoader__.load({
       }
 
       // Rung 1 — `using()`: the documented helper, present from 0.1.6-alpha.2.
+      // 与 Rung 2 必须对称地包 try/catch：`using()` 本身（或它内部的
+      // `no-session-face` 抛出）一失败就该降级到 retain → inputActions →
+      // draft，而不是让整个"改发到主对话"断在这里 —— 后两档存在的理由
+      // 正是这种情况。`prompt-rejected` 仍然照旧抛给调用方（那是用户可见的
+      // 拒绝，不是通道缺失）。
       if (sessionId !== null && typeof sessions?.using === 'function') {
-        const result = await sessions.using(sessionId, { source: 'gateway' }, async (reference) => {
-          const face = reference?.binding?.session
-          if (face === undefined || typeof face.prompt !== 'function') {
-            throw Object.assign(new Error('session face has no prompt()'), { code: 'no-session-face' })
-          }
-          return face.prompt(parts, 'queue')
-        })
-        accepted(result)
-        return { mode: 'session', via: 'sessions.using' }
+        try {
+          const result = await sessions.using(sessionId, { source: 'gateway' }, async (reference) => {
+            const face = reference?.binding?.session
+            if (face === undefined || typeof face.prompt !== 'function') {
+              throw Object.assign(new Error('session face has no prompt()'), { code: 'no-session-face' })
+            }
+            return face.prompt(parts, 'queue')
+          })
+          accepted(result)
+          return { mode: 'session', via: 'sessions.using' }
+        } catch (error) {
+          if (error?.code === 'prompt-rejected') throw error
+          console.warn(`[${PLUGIN_ID}] sessions.using 提交失败，尝试下一级：`, error)
+        }
       }
 
       // Rung 2 — `retain()` + explicit release: the same operation spelled out,
@@ -2307,8 +2317,22 @@ window.__ModuleLoader__.load({
         cardId: null,
         open(card) {
           if (!this.available() || typeof this.controller.openTab !== 'function') return false
+          // 同一个 kind 在原生栏里只有一个地址（见 cardId 的注释）：先把栏里
+          // 其它卡片迁回浮层，否则它们既不在栏里也不在浮层上，流式输出还会
+          // 继续往一张看不见的卡片里写。
+          for (const other of store.state.cards) {
+            if (other.id !== card.id && other.surface === 'native-rightbar') {
+              patchCard(other.id, { surface: 'flow' })
+            }
+          }
           this.cardId = card.id
-          this.controller.openTab(CARD_KIND, { params: { cardId: card.id }, revealIfOpened: true })
+          try {
+            this.controller.openTab(CARD_KIND, { params: { cardId: card.id }, revealIfOpened: true })
+          } catch (error) {
+            // 开栏失败就把地址回滚，免得 CardHost 去渲染一张根本没有 tab 的卡。
+            this.cardId = null
+            throw error
+          }
           return true
         },
         close(card) {
@@ -2319,6 +2343,10 @@ window.__ModuleLoader__.load({
           // and lets CardHost show its closed-card face.
           const controller = this.controller
           if (controller === null || controller === undefined) return false
+          // 归属校验：栏里那条同 kind 的 tab 若正被另一张卡片占用，就不能替它
+          // 关掉（否则关 A 会把 B 的 tab 一起关掉）。cardId === null 是"清理
+          // 残留 tab"的路径，此时按 kind 关是对的。
+          if (this.cardId !== null && this.cardId !== card.id) return false
           let rows = []
           try {
             rows = typeof controller.openTabs?.getSnapshot === 'function'
@@ -2328,6 +2356,12 @@ window.__ModuleLoader__.load({
           const row = Array.isArray(rows)
             ? rows.find(entry => entry?.kind === CARD_KIND
               && typeof entry?.tabId === 'string' && entry.tabId !== ''
+              // 单地址模型下这里只该有一行；万一宿主保留了多行，必须关"属于这张
+              // 卡片"的那一行（openTab 把 cardId 写进 params → contentId），
+              // 否则会替另一张卡片关掉它的 tab。
+              && (typeof entry?.contentId !== 'string'
+                || entry.contentId === ''
+                || entry.contentId === card.id)
               && (typeof entry?.sessionId !== 'string'
                 || store.state.sessionId === null
                 || entry.sessionId === store.state.sessionId))
@@ -5841,13 +5875,32 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           } catch { return [] }
         }
 
+        /** 是否是「本版本自己写下的空信封」（带 writtenAt 标记）。 */
+        function isOwnedEmptyEnvelope(raw) {
+          try {
+            const value = JSON.parse(raw)
+            return value !== null
+              && typeof value === 'object'
+              && value.version === 3
+              && Array.isArray(value.cards)
+              && Number.isFinite(value.writtenAt)
+          } catch {
+            return false
+          }
+        }
+
         function readPersisted() {
           let raw = null
           try {
             raw = window.localStorage?.getItem(PERSIST_KEY)
           } catch { return [] }
           const v3 = parseEnvelope(raw, 3).slice(0, 50)
-          if (v3.length > 0 || (raw !== null && raw !== undefined)) return v3
+          if (v3.length > 0) return v3
+          // 空的 v3 信封只有在「本版本自己写的」时候才算权威：它带 writtenAt，
+          // 说明用户确实把历史清空了，此时绝不能回落到 v2/v1 把旧记录复活。
+          // 而没有 writtenAt 的空信封（旧版本写的 / 迁移中途留下的）或损坏的
+          // JSON 必须继续向下探测 —— 否则 v1、v2 的数据会被永久挡住。
+          if (raw !== null && raw !== undefined && isOwnedEmptyEnvelope(raw)) return v3
           // v2 → v3: v2 entries have no `versions`, so the field is seeded empty.
           let v2raw = null
           try {
@@ -5881,7 +5934,7 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
           let lastError = null
           for (;;) {
             try {
-              window.localStorage?.setItem(PERSIST_KEY, JSON.stringify({ version: 3, cards: remaining }))
+              window.localStorage?.setItem(PERSIST_KEY, JSON.stringify({ version: 3, cards: remaining, writtenAt: Date.now() }))
               return remaining
             } catch (error) {
               lastError = error
@@ -5907,7 +5960,6 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             .filter(card => card.carrier === 'side'
               && (card.status === 'done' || card.status === 'stopped')
               && card.text !== '')
-            .slice(0, cap)
             .map(card => ({
               id: card.id,
               question: card.question,
@@ -5923,7 +5975,10 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
               createdAt: Number.isFinite(card.createdAt) ? card.createdAt : Date.now(),
               provider: typeof card.provider === 'string' ? card.provider : '',
               elapsedMs: Number.isFinite(card.elapsedMs) ? card.elapsedMs : null,
-              history: Array.isArray(card.history) ? card.history.slice(-12) : [],
+              // 持久化的历史轮次与上下文预算同一个上限（HISTORY_TURNS）：
+              // 这里曾经写死 `slice(-12)`，而 followUp 只发 6 轮，多出来的
+              // 6 轮永远不会被读，是纯死重量。
+              history: Array.isArray(card.history) ? card.history.slice(-HISTORY_TURNS) : [],
               // P2-2: kept so a replayed rewrite card still offers "insert".
               actionId: typeof card.actionId === 'string' ? card.actionId.slice(0, 60) : null,
               // P2-5b: bounded, text-capped older answers. `question` is short
@@ -5947,7 +6002,24 @@ body[data-ds-dark-theme] .dsa-seg button[data-on="true"]:hover{
             store.set({ history: [] })
             return
           }
-          const persisted = writePersisted(finished)
+          // #6（2026-10-26 修复）：关闭一张卡片只把它从「活跃区」移除，
+          // durable 快照仍然留在 store.history 里。这里过去只从活跃卡片
+          // 重建整个集合再整键覆盖，于是「关掉的那张」会在下一次答题完成
+          // 时被静默抹掉（contract-test 把破坏后的结果当成了期望）。
+          // 现在写的是并集：活跃卡片 ∪ 尚未关闭的历史条目（按 id 去重，
+          // 活跃方优先），再按 newest-first 截到 cap。
+          // 删除路径（deleteCard / deleteHistoryCard / 改投主对话 /
+          // clearHistory）都是先改 store.history 再写盘，所以并集不会把它们
+          // 删掉的条目复活。
+          const liveIds = new Set(finished.map(entry => entry.id))
+          const kept = store.state.history.filter(entry => entry !== null
+            && typeof entry === 'object'
+            && typeof entry.id === 'string'
+            && !liveIds.has(entry.id))
+          const merged = [...finished, ...kept]
+            .sort((left, right) => (Number(right.createdAt) || 0) - (Number(left.createdAt) || 0))
+            .slice(0, cap)
+          const persisted = writePersisted(merged)
           store.set({ history: persisted })
         }
 

package/index.js

@@ -45,7 +45,7 @@ export const name = 'dsh-sidecard-ask'
 export const inject = ['webServer']
 
 /** Version of this plugin (kept in step with package.json by test/verify.mjs). */
-export const PLUGIN_VERSION = '2.1.3'
+export const PLUGIN_VERSION = '2.1.4'
 
 /** Route prefix of the plugin's own API. */
 export const ROUTE_PREFIX = '/sidecard-ask/api'
@@ -1541,7 +1541,7 @@ function openSse(res) {
  * Build the engine that owns every side-card run.
  * @param {import('@deepseek-ai/cordis').Context} ctx - host plugin context.
  * @param {() => Record<string, unknown>} configOf - live config reader.
- * @returns {{ask: Function, cancel: Function, activeIds: Function, dispose: Function, capabilities: Function}}
+ * @returns {{ask: Function, cancel: Function, dispose: Function, capabilities: Function}}
  */
 function createSideEngine(ctx, configOf) {
   /** id → run record. */
@@ -1630,6 +1630,11 @@ function createSideEngine(ctx, configOf) {
         parent: fields.parent,
         ...(fields.persona === undefined ? {} : { persona: fields.persona }),
         ...(fields.toolFilter === undefined ? {} : { toolFilter: fields.toolFilter }),
+        // 0.2.1-alpha.2+ 的 `request` 与旧 `start(provider, request)` 是同一个
+        // SubagentStartRequest 形状，`agentPreset` 必须一起转发。漏掉这一项
+        // 会让子代理拿到默认全套工具，而 start 帧仍按配置上报
+        // `toolFilter: 'preset'`，卡片于是对用户谎报"工具集由 preset 决定"。
+        ...(fields.agentPreset === undefined ? {} : { agentPreset: fields.agentPreset }),
       },
     })
     return {
@@ -1893,7 +1898,6 @@ function createSideEngine(ctx, configOf) {
     /** Which source produced deltas: process-local frames or durable chunks. */
     let framesSeen = false
     let chunksSeen = false
-    let finished = false
 
     /** Detach this run's stream listener (frames are per attempt). */
     let detach = () => {}
@@ -2078,7 +2082,6 @@ function createSideEngine(ctx, configOf) {
         })
         return
       }
-      finished = true
       sink.send('done', {
         id,
         text,
@@ -2140,9 +2143,12 @@ function createSideEngine(ctx, configOf) {
     }
     runs.clear()
     streamListeners.clear()
+    // 第二个流来源的订阅者也要清：只清 streamListeners 会在插件卸载后
+    // 留下仍被 `session/event` 桥持有的闭包（它捕获了整个 engine 状态）。
+    chunkListeners.clear()
   }
 
-  return { ask, cancel, dispose, capabilities, activeIds: () => [...runs.keys()] }
+  return { ask, cancel, dispose, capabilities }
 }
 
 // ────────────────────────────────────────────────────────────────────────────
@@ -2594,7 +2600,10 @@ export function apply(ctx, patchConfig) {
       writeError(res, 400, 'bad-request', '缺少 id')
       return
     }
-    writeOk(res, { cancelled: engine.cancel(id), active: engine.activeIds() })
+    // 只回本次取消的结果：`runs` 是跨会话的全局表，把它的 id 列表回给
+    // 任意可信页面等于泄露别的会话正在追问的卡片 id（而 cancel 本身也不
+    // 校验归属），Client 侧也没有任何地方消费这个字段。
+    writeOk(res, { cancelled: engine.cancel(id) })
   }
 
   /** `/config` — merge a partial config into the user layer and persist it. */
@@ -2707,7 +2716,16 @@ export function apply(ctx, patchConfig) {
   /** One request → one response; the dispatcher owns path parsing and the fence. */
   const routeHandler = async (req, res) => {
     if (!isTrustedRequest(req, trustedHostsOf())) {
-      writeError(res, 403, 'forbidden', 'forbidden')
+      // 说明"为什么被拒 + 怎么放行"：这条 403 只会出现在 DSH 被绑到非回环
+      // 地址、或经反向代理访问时（Host 既不是 loopback，也不在 trustedHosts
+      // 里）。有意不自动信任绑定地址：插件读不到宿主的 bind 配置，猜一个就等于
+      // 自己把 DNS-rebinding 防线拆掉。
+      writeError(
+        res,
+        403,
+        'forbidden',
+        'Host 不在信任范围：请用 http://127.0.0.1:<端口> 访问，或把该地址写进 trustedHosts 配置',
+      )
       return
     }
     // Path parsing runs BEFORE the session gate now, because `ping` must be

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-sidecard-ask",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "description": "DSH 划词追问（侧边卡片作答）：在聊天区与任务区选中文本就地追问，答案由独立子代理在侧边卡片里流式呈现，也可选择落回主对话。",
   "type": "module",
   "main": "index.js",