dsh-edit-turn 0.5.8 → 0.5.9

package/README.md

@@ -277,6 +277,16 @@ ln -s /path/to/dsh-install/node_modules ./node_modules
 
 ### 更新日志
 
+**0.5.9** —— `/state` 瘦身：回复只发身份、全文按需取。
+
+- **根因（两个症状同一个原因）**：`/state` 把每条回复的**整轮**推理与正文全文都发了出去。实测一个会话 291 条回复 = **27.9 MB**，一次 `/state` 要 **13 秒**。于是在它回来之前浏览器里没有任何编辑条目：笔图标迟迟不出现，**复制也就不会被本插件接管**（用户按复制时视图还是空的，按下落到宿主自己的处理上，复制出改写前的原文）。
+
+- **修法**：`/state` 的 `replies` 只发身份 —— `seq` / `turn` / `messageId` / `attachments` / `textLength` / `blockCount`。全文与分块走新的 `GET /dsh-edit-turn/reply?sessionId=&messageId=`，只在真正需要时取一次（**按回复复制**、或打开编辑器），浏览器半部拿到后按 messageId 缓存。
+
+- 宿主与客户端同步改：两个"打开回复编辑器"的入口与回复的复制按钮都改成"先取全文再动作"，`currentTarget` 在 await 之前读出来（React 派发结束后它会变 null）。
+
+- 测试改为断言新契约，并顺带覆盖新路由（`/state` 不再带 `blocks`，`/reply` 返回分块与原文）。
+
 **0.5.8** —— 复制交给**平台写入器这一层**兜底：不管按下走哪条路，落到剪贴板的都是改写后的文本。
 
 - **0.5.7 没修好**：那一版把"回答按下"从按钮节点挪到了文档级捕获监听（按行匹配，节点被重画也不影响），但实测仍然复制出原文。说明这次按下**根本没有经过本插件能拦到的按钮**——具体是哪个环节，从外部看不出来（没有可用的浏览器来读真实 DOM）。

package/lib/client.js

@@ -45,7 +45,7 @@ window.__ModuleLoader__.load({
     const RERUN_PREFIX = '/dsh-rerun-turn'
 
     /** Keep in sync with package.json and lib/index.js. */
-    const PLUGIN_VERSION = '0.5.8'
+    const PLUGIN_VERSION = '0.5.9'
 
     // --- copy -----------------------------------------------------------------
 
@@ -141,6 +141,7 @@ window.__ModuleLoader__.load({
       'error.attachment-too-large': '这个文件太大，无法作为附件。',
       'error.too-large': '这次修改太大，服务器没有接收。',
       'error.replay-partial': '已保存并改写了这条回答，但后面的轮次没能全部重放回来，请重新打开会话确认。',
+      'error.reply-not-found': '这条回答已经不可编辑了（可能已被改写或不在当前上下文里）。',
     }
 
     const en = {
@@ -230,6 +231,7 @@ window.__ModuleLoader__.load({
       'error.attachment-too-large': 'That file is too large to attach.',
       'error.too-large': 'That revision was too large for the host to accept.',
       'error.replay-partial': 'Saved and corrected, but the turns after it could not all be replayed; reopen the session to check.',
+      'error.reply-not-found': 'That reply is no longer editable (it may have been rewritten, or left the current context).',
     }
 
     // Every error code the host can return travels through here. A code is
@@ -645,6 +647,9 @@ window.__ModuleLoader__.load({
         this.sessionId = sessionId
         this.listeners = new Set()
         this.inflight = null
+        // One reply's full wording, fetched on demand and kept: `/state` ships
+        // identities only (a reply carries its whole turn's text).
+        this.replyBodies = new Map()
         this.animateOnce = false
         this.rowCount = -1
         this.editor = null
@@ -749,6 +754,32 @@ window.__ModuleLoader__.load({
         return value
       }
 
+      /**
+       * One reply's full wording and blocks, on demand.
+       *
+       * `/state` publishes identities only: a reply carries its whole turn's
+       * reasoning and answer text, and a long session's list ran to 27.9 MB -
+       * 13 seconds for one refresh, which is why the edit entry appeared so late.
+       *
+       * @param {string} messageId - the reply's message id.
+       * @returns {Promise<object|null>} `{ text, blocks, attachments }`, or null.
+       */
+      replyBody(messageId) {
+        if (typeof messageId !== 'string' || messageId === '') return Promise.resolve(null)
+        const cached = this.replyBodies.get(messageId)
+        if (cached !== undefined) return cached
+        const url = `${ROUTE_PREFIX}/reply?sessionId=${encodeURIComponent(this.sessionId)}&messageId=${encodeURIComponent(messageId)}`
+        const pending = fetch(url, { headers: { accept: 'application/json' } })
+          .then(async (res) => {
+            const data = await res.json().catch(() => ({}))
+            if (!res.ok || !data.ok) throw new Error(data && data.error ? String(data.error) : `HTTP ${res.status}`)
+            return { text: data.text, blocks: Array.isArray(data.blocks) ? data.blocks : [], attachments: data.attachments }
+          })
+          .catch(() => null)
+        this.replyBodies.set(messageId, pending)
+        return pending
+      }
+
       load(force) {
         // A refresh asked for while one is already running has to land *after*
         // it: handing back the in-flight response would answer with a snapshot
@@ -4827,37 +4858,55 @@ window.__ModuleLoader__.load({
       const open = (event) => {
         event.preventDefault()
         event.stopPropagation()
-        controller.open({
-          anchor: event.currentTarget,
-          seq: entry.seq,
-          mode: 'reply',
-          turn: entry.turn,
-          messageId: entry.messageId,
-          text: typeof entry.text === 'string' ? entry.text : '',
-          attachments: typeof entry.attachments === 'number' ? entry.attachments : 0,
-          ...(Array.isArray(entry.blocks) ? { blocks: entry.blocks, patch: true } : { blocks: [] }),
-        })
+        // `currentTarget` is null once this handler returns, so it is read before
+        // the await that may fetch the reply's wording.
+        const anchor = event.currentTarget
+        void (async () => {
+          let body = null
+          if (!Array.isArray(entry.blocks) && typeof entry.blockCount === 'number' && entry.blockCount > 0) {
+            body = await controller.replyBody(entry.messageId)
+          }
+          const blocks = body !== null && Array.isArray(body.blocks)
+            ? body.blocks
+            : Array.isArray(entry.blocks) ? entry.blocks : []
+          controller.open({
+            anchor,
+            seq: entry.seq,
+            mode: 'reply',
+            turn: entry.turn,
+            messageId: entry.messageId,
+            text: body !== null && typeof body.text === 'string'
+              ? body.text
+              : typeof entry.text === 'string' ? entry.text : '',
+            attachments: typeof entry.attachments === 'number' ? entry.attachments : 0,
+            ...(blocks.length > 0 ? { blocks, patch: true } : { blocks: [] }),
+          })
+        })()
       }
       const copy = (event) => {
         event.preventDefault()
         event.stopPropagation()
-        const text = replyCopyText(entry)
-        if (text === '') return
-        const write = primitives !== null && primitives !== undefined && typeof primitives.writeClipboard === 'function'
-          ? primitives.writeClipboard
-          : typeof navigator !== 'undefined' && navigator.clipboard && typeof navigator.clipboard.writeText === 'function'
-            ? (value) => navigator.clipboard.writeText(value)
-            : null
-        if (write === null) return
-        Promise.resolve()
-          .then(() => write(text))
-          .then(
-            () => {
-              setCopied(true)
-              window.setTimeout(() => setCopied(false), 1200)
-            },
-            () => {},
-          )
+        void (async () => {
+          let text = replyCopyText(entry)
+          if (text === '' && typeof entry.blockCount === 'number' && entry.blockCount > 0) {
+            const body = await controller.replyBody(entry.messageId)
+            if (body !== null) text = replyCopyText(body)
+          }
+          if (text === '') return
+          const write = primitives !== null && primitives !== undefined && typeof primitives.writeClipboard === 'function'
+            ? primitives.writeClipboard
+            : typeof navigator !== 'undefined' && navigator.clipboard && typeof navigator.clipboard.writeText === 'function'
+              ? (value) => navigator.clipboard.writeText(value)
+              : null
+          if (write === null) return
+          try {
+            await write(text)
+          } catch {
+            return
+          }
+          setCopied(true)
+          window.setTimeout(() => setCopied(false), 1200)
+        })()
       }
       return jsxs('div', {
         className: 'dshet-tail',

package/lib/index.js

@@ -78,7 +78,7 @@ export const PLUGIN_ID = 'dsh-edit-turn'
 export const name = PLUGIN_ID
 
 /** Keep in sync with package.json and lib/client.js. */
-export const PLUGIN_VERSION = '0.5.8'
+export const PLUGIN_VERSION = '0.5.9'
 
 // A ring of the last few requests, answering "did the browser half even ask, and
 // what did it get?" without needing its console. Read-only diagnostics: the
@@ -1686,6 +1686,50 @@ export async function attachmentBytes(ctx, sessionId, seq, index) {
 
 // --- operations --------------------------------------------------------------
 
+/**
+ * A reply's identity, without its words.
+ *
+ * One reply carries every reasoning and answer block of its **turn**, so a long
+ * session's reply list is tens of megabytes: measured 291 replies = 27.9 MB, and
+ * a single `/state` took 13 seconds - long enough that the browser showed no edit
+ * entry, and slow enough to look like the plugin had not loaded at all. The words
+ * are fetched when the user actually wants them (`/reply`).
+ *
+ * @param {object} entry - one entry from `editableReplies`.
+ * @returns {object} the identity-only projection.
+ */
+export function lightReply(entry) {
+  return {
+    seq: entry.seq,
+    turn: entry.turn,
+    messageId: entry.messageId,
+    attachments: entry.attachments,
+    textLength: typeof entry.text === 'string' ? entry.text.length : 0,
+    blockCount: Array.isArray(entry.blocks) ? entry.blocks.length : 0,
+  }
+}
+
+/**
+ * One reply's full wording and blocks, for a copy press or an opened editor.
+ *
+ * @param ctx - plugin context.
+ * @param {string} sessionId - the session.
+ * @param {object} config - resolved config.
+ * @param {string} messageId - the reply's message id.
+ * @returns {Promise<object|null>} `{ text, blocks, attachments }`, or null.
+ */
+async function replyOf(ctx, sessionId, config, messageId) {
+  const events = await readEvents(ctx, sessionId)
+  if (!events) return null
+  const folded = foldSurface(events)
+  const entry = editableReplies(events, folded.nodes, {
+    patches: patchesOf(events),
+    patch: config.patch === true,
+  }).find((candidate) => candidate.messageId === messageId)
+  if (entry === undefined) return null
+  return { text: entry.text, blocks: entry.blocks, attachments: entry.attachments }
+}
+
 async function stateOf(ctx, sessionId, config) {
   const events = await readEvents(ctx, sessionId)
   if (!events) {
@@ -1734,7 +1778,7 @@ async function stateOf(ctx, sessionId, config) {
   // editor promising to keep blocks the host would have to drop.
   const store = resolveAttachmentStore(ctx)
   const turns = editableTurns(events, folded.nodes, { preview: canPreviewAttachments(store) })
-  const replies = editableReplies(events, folded.nodes, { patches, patch: config.patch === true })
+  const replies = editableReplies(events, folded.nodes, { patches, patch: config.patch === true }).map(lightReply)
   noteRequest({
     kind: 'state',
     sessionId,
@@ -2587,6 +2631,33 @@ export function apply(ctx, config) {
       }),
     )
 
+    // One reply's wording and blocks, on demand: `/state` publishes identities
+    // only, because a reply can carry a whole turn's worth of text.
+    fiber.effect(() =>
+      webServer.register({
+        kind: 'exact',
+        path: `${ROUTE_PREFIX}/reply`,
+        handler: async (req, res) => {
+          if (!guard(req, res)) return
+          if (req.method !== 'GET') {
+            sendJson(res, 405, { ok: false, code: 'method', error: 'GET only' })
+            return
+          }
+          try {
+            const url = new URL(req.url ?? '/', 'http://127.0.0.1')
+            const sessionId = requireSessionId(url.searchParams.get('sessionId') ?? '')
+            const messageId = String(url.searchParams.get('messageId') ?? '').trim()
+            if (messageId === '') throw new HttpError(400, 'invalid', 'messageId required')
+            const body = await replyOf(ctx, sessionId, resolved, messageId)
+            if (body === null) throw new HttpError(404, 'reply-not-found', 'this reply is not editable')
+            sendJson(res, 200, { ok: true, messageId, ...body })
+          } catch (error) {
+            failure(res, error)
+          }
+        },
+      }),
+    )
+
     // The bytes behind one block, for the editor's chips. Read-only, loopback
     // and same-origin like everything else here, and answered only for a block
     // the session's own log cites.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "description": "Edit any message in DeepSeek Harness in place: a prompt is replaced where it stands; a model reply block (answer text or reasoning) is patched through a plugin record and a message projection, so the turn stays where it is, later turns are untouched and the log grows by one small record. Falls back to the replay splice on hosts without the projection API. The append-only session log is never rewritten.",
   "type": "module",
   "main": "lib/index.js",