dsh-as-aistudio 0.4.1 → 0.4.3

package/CHANGELOG.md

@@ -4,6 +4,22 @@
 
 ## 中文
 
+**0.4.3** —— 编辑入口不再"等半天才出现"（`/state` 从 25 MB 降到几百 KB）。
+
+- **组件跟进**：`dsh-edit-turn` **0.5.9**（另三个不变：`dsh-rerun-turn` 0.2.6、`dsh-delete-turn` 0.1.15、`dsh-markdown-bubble` 0.1.5）。
+
+- **症状**：编辑笔要等很久才出现；而且在这之前按复制，拿到的是改写前的原文。
+
+- **根因（两件事同一个原因）**：`dsh-edit-turn` 的 `/state` 把每条回复的**整轮**推理与正文全文都发了出去。实测一个会话 291 条回复 = **27.9 MB**，一次 `/state` 要 **13 秒**。这段时间里浏览器半部没有任何编辑条目 —— 笔不出现，复制也就不会被插件接管。
+
+- **修法**：`/state` 的 `replies` 只发身份（`seq` / `turn` / `messageId` / `attachments` / `textLength` / `blockCount`），全文与分块走新的 `/reply` 接口，只在按复制或打开编辑器时取一次。
+
+**0.4.2** —— 复制拿到改写后的文本（改到平台写入器这一层）。
+
+- **组件跟进**：`dsh-edit-turn` **0.5.8**（另三个不变：`dsh-rerun-turn` 0.2.6、`dsh-delete-turn` 0.1.15、`dsh-markdown-bubble` 0.1.5）。
+
+- 0.4.1 里跟进的 0.5.7 没修好：它把"回答复制按下"从按钮节点挪到文档级捕获监听，实测仍复制出原文，说明这次按下没有经过那条路。0.5.8 换到**所有复制都要经过的唯一关口**——`navigator.clipboard.writeText`（宿主自己的 `writeClipboard` 原语内部就是调它）：写入的文本如果正是某条被改写消息的原文，就换成改写后的文本，其余写入一字不动。登记表放在页级（`globalThis` 上的 Symbol），因为实时重载后旧 bundle 装的包装器仍在写入路径上。
+
 **0.4.1** —— 编辑过的消息，复制按钮被宿主重画之后仍然复制改写后的文本。
 
 - **组件跟进**：`dsh-edit-turn` **0.5.7**（另三个不变：`dsh-rerun-turn` 0.2.6、`dsh-delete-turn` 0.1.15、`dsh-markdown-bubble` 0.1.5）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-as-aistudio",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Google-AI-Studio-style turn controls for DeepSeek Harness, in one install: edit a prompt and re-run it, re-run a reply in place, delete a turn from the model context, and render sent prompts as Markdown. Self-contained: the plugin list shows this one row, and the four components are vendored inside it - installing the studio installs nothing else.",
   "type": "module",
   "main": "src/index.js",

package/src/client.js

@@ -43,7 +43,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.7'
+    const PLUGIN_VERSION = '0.5.9'
 
     // --- copy -----------------------------------------------------------------
 
@@ -139,6 +139,7 @@ window.__ModuleLoader__.load({
       'error.attachment-too-large': '这个文件太大，无法作为附件。',
       'error.too-large': '这次修改太大，服务器没有接收。',
       'error.replay-partial': '已保存并改写了这条回答，但后面的轮次没能全部重放回来，请重新打开会话确认。',
+      'error.reply-not-found': '这条回答已经不可编辑了（可能已被改写或不在当前上下文里）。',
     }
 
     const en = {
@@ -228,6 +229,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
@@ -643,6 +645,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
@@ -747,6 +752,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
@@ -1935,6 +1966,10 @@ window.__ModuleLoader__.load({
     const COPY_TIMER = 'dshetCopyTimer'
     /** The host draws its own check for a second; this is the same second. */
     const COPY_FEEDBACK_MS = 1000
+    /** 标记：这一页的剪贴板写入已经被本半部包过一次（重载会复用同一个 page）。 */
+    const CLIPBOARD_WRAPPED = Symbol.for('dshetClipboardWrapped')
+    /** 页级登记表：重载后新 bundle 与旧包装器共用同一份。 */
+    const COPY_REGISTRY = Symbol.for('dshetCopyRegistry')
     /**
      * Row key -> the text that row's copy button must hand over.
      *
@@ -1945,7 +1980,25 @@ window.__ModuleLoader__.load({
      * the button it drew goes away with that node (the button it draws next is a
      * different one).
      */
-    const rowCopyText = new Map()
+    /**
+     * Row key -> the text that row's copy must hand over, and the wording the host
+     * would hand over instead.
+     *
+     * Both live on the PAGE rather than in this module: a live reload builds a new
+     * bundle with new maps, and the clipboard wrapper the previous bundle installed
+     * is still the one in the write path (wrapping is idempotent, by design). Two
+     * maps would leave that wrapper reading a registry nobody fills.
+     */
+    const copyRegistry = (() => {
+      const page = typeof globalThis !== 'undefined' ? globalThis : {}
+      const existing = page[COPY_REGISTRY]
+      if (existing !== undefined && existing !== null && existing.text instanceof Map) return existing
+      const created = { text: new Map(), host: new Map() }
+      page[COPY_REGISTRY] = created
+      return created
+    })()
+    const rowCopyText = copyRegistry.text
+    const rowHostText = copyRegistry.host
 
     /**
      * A button another plugin put in this bar.
@@ -2009,13 +2062,93 @@ window.__ModuleLoader__.load({
      * host's own clipboard writer the button keeps the host's behaviour too: a
      * takeover that cannot copy is worse than none.
      */
+    /**
+     * The wording the host's own copy button would hand over for this row.
+     *
+     * It is the message the row was drawn for - the pre-edit text - and it is read
+     * off the row itself, because that is where it still is: this plugin hides the
+     * row's own bubble and stands its revision in front of it.
+     *
+     * @param {Element} row - the row.
+     * @returns {string|null} the host's text, or null when it cannot be read.
+     */
+    function hostCopyTextOf(row) {
+      try {
+        const bubble = ownRevisionBubble(row)
+        let text = ''
+        const children = row.childNodes
+        if (children === undefined || children === null) return null
+        for (const child of children) {
+          if (bubble !== null && child === bubble) continue
+          if (typeof child.textContent === 'string') text += child.textContent
+        }
+        const normalized = text.replace(/\s+/g, ' ').trim()
+        return normalized === '' ? null : normalized
+      } catch {
+        return null
+      }
+    }
+
+    /**
+     * The wording that must actually land on the clipboard.
+     *
+     * The host's copy button copies the message its row was drawn for, so on a row
+     * this plugin rewrote it hands over the pre-edit text. The press itself is
+     * answered earlier when this half can find the button, but the action bar is the
+     * host's own React and it may draw a button this half never marked - so the last
+     * say belongs to the write itself, which no button and no handler can bypass.
+     *
+     * @param {string} text - what the platform is about to write.
+     * @returns {string|null} the text to write instead, or null to leave it alone.
+     */
+    function rewriteCopiedText(text) {
+      const wanted = text.replace(/\s+/g, ' ').trim()
+      if (wanted === '') return null
+      for (const [key, edited] of rowCopyText) {
+        if (typeof edited !== 'string') continue
+        if (edited.replace(/\s+/g, ' ').trim() === wanted) return null
+        const hostText = rowHostText.get(key)
+        if (typeof hostText === 'string' && (hostText === wanted || hostText.includes(wanted))) return edited
+      }
+      return null
+    }
+
+    /**
+     * Wrap the platform's clipboard writer, once per page.
+     *
+     * `navigator.clipboard.writeText` is the single choke point every copy goes
+     * through - the host's own `writeClipboard` primitive calls it, and so does a
+     * browser's native copy of a selection.
+     *
+     * @returns {() => void} undo.
+     */
+    function installClipboardRewrite() {
+      const clipboard = typeof navigator !== 'undefined' ? navigator.clipboard : undefined
+      if (clipboard === undefined || clipboard === null || typeof clipboard.writeText !== 'function') return () => {}
+      if (clipboard.writeText[CLIPBOARD_WRAPPED] === true) return () => {}
+      const native = clipboard.writeText.bind(clipboard)
+      const wrapped = (value) => {
+        const rewritten = rewriteCopiedText(String(value ?? ''))
+        return rewritten === null ? native(value) : native(rewritten)
+      }
+      wrapped[CLIPBOARD_WRAPPED] = true
+      clipboard.writeText = wrapped
+      return () => {
+        if (clipboard.writeText === wrapped) clipboard.writeText = native
+      }
+    }
+
     function takeOverRowCopy(row, text, t) {
       // Registered before the button lookup on purpose: the handover has to work
       // even when this pass cannot find the button to mark (the next one may, and
       // the document-level press answers from this table either way).
       {
         const key = row.getAttribute('data-chat-flow-key')
-        if (typeof key === 'string' && key !== '') rowCopyText.set(key, text)
+        if (typeof key === 'string' && key !== '') {
+          rowCopyText.set(key, text)
+          const hostText = hostCopyTextOf(row)
+          if (hostText !== null) rowHostText.set(key, hostText)
+        }
       }
       const button = nativeCopyButton(row, t)
       if (button === null) return
@@ -2146,7 +2279,10 @@ window.__ModuleLoader__.load({
     /** The copy handover of a row, wherever the last pass left it. */
     function releaseRowCopy(row) {
       const key = row.getAttribute('data-chat-flow-key')
-      if (typeof key === 'string' && key !== '') rowCopyText.delete(key)
+      if (typeof key === 'string' && key !== '') {
+        rowCopyText.delete(key)
+        rowHostText.delete(key)
+      }
       const button = nativeCopyButton(row)
       if (button !== null) releaseCopyButton(button)
     }
@@ -4720,37 +4856,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',
@@ -4791,6 +4945,10 @@ window.__ModuleLoader__.load({
         controller.load()
       }, [controller])
 
+      // The last say on what lands: whatever route the press takes, the write
+      // itself goes through here.
+      react.useEffect(() => installClipboardRewrite(), [])
+
       // Pressing outside the editor is the one signal that means "the user
       // left". Blur cannot be that signal: a host re-render replaces the node
       // (blur without a related target) and a save temporarily disables it -
@@ -9038,7 +9196,7 @@ window.__ModuleLoader__.load({
     const NS = 'dsh-as-aistudio'
 
     /** Keep in sync with package.json and src/components.js. */
-    const PLUGIN_VERSION = '0.4.1'
+    const PLUGIN_VERSION = '0.4.3'
 
     /** Presence marker the live verifier reads. */
     const DEBUG_KEY = '__DSH_AS_AISTUDIO__'

package/src/components.js

@@ -26,7 +26,7 @@
 export const STUDIO_ID = 'dsh-as-aistudio'
 
 /** Keep in sync with package.json and src/client.js. */
-export const STUDIO_VERSION = '0.4.1'
+export const STUDIO_VERSION = '0.4.3'
 
 /**
  * The AI Studio action strip this studio composes, in the order the user meets

package/src/vendor/host/dsh-edit-turn.js

@@ -1,6 +1,6 @@
 // dsh-edit-turn host half (dsh-edit-turn.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-edit-turn/lib/index.js  (v0.5.7, sha256 32dc3ed4d66bb063)
+// Source: ../dsh-edit-turn/lib/index.js  (v0.5.9, sha256 a007714c89acfae5)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the
@@ -85,7 +85,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.7'
+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
@@ -1693,6 +1693,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) {
@@ -1741,7 +1785,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,
@@ -2594,6 +2638,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/src/vendor/host/dsh-edit-turn.patch.js

@@ -1,6 +1,6 @@
 // dsh-edit-turn host half (dsh-edit-turn.patch.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-edit-turn/lib/patch.js  (v0.5.7, sha256 5e1e8cce1d168f6c)
+// Source: ../dsh-edit-turn/lib/patch.js  (v0.5.9, sha256 5e1e8cce1d168f6c)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the

package/src/vendor/versions.json

@@ -1,5 +1,5 @@
 {
-  "dsh-edit-turn": "0.5.7",
+  "dsh-edit-turn": "0.5.9",
   "dsh-rerun-turn": "0.2.6",
   "dsh-delete-turn": "0.1.15",
   "dsh-markdown-bubble": "0.1.5"