dsh-edit-turn 0.5.0 → 0.5.3

package/lib/index.js

@@ -80,7 +80,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.0'
+export const PLUGIN_VERSION = '0.5.3'
 
 // 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
@@ -100,7 +100,15 @@ export function recentRequests() {
 }
 
 const ROUTE_PREFIX = '/dsh-edit-turn'
-const SESSION_ID_RE = /^(session-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+// A session id is an OPAQUE string to DSH: the host's own schema is
+// `z.string().min(1)`, and a named session created in the GUI (`bili-whale`,
+// stored as ~/.dsh/storages/<profile>/sessions/bili-whale.json) is exactly as
+// real as a UUID one. A UUID-only test rejected those with a 400, so the panel
+// answered "状态加载失败" for a session that plainly exists. The character class
+// still refuses everything that could leave a path or a URL: `/`, `\`, `..`
+// (the first character must be alphanumeric, so a leading dot is already out),
+// whitespace and control characters.
+const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/
 const MAX_TEXT = 200_000
 const FLUSH_DEADLINE_MS = 5_000
 
@@ -162,6 +170,10 @@ export const Config =
          * replay splice otherwise; `patch` refuses to run without the
          * projection; `replay` always uses the old path. Prompt edits always use
          * the official surface replacement.
+         *
+         * There is deliberately no `replace` value: appending a fresh
+         * `assistant/message` with a replace op is refused by the session's own
+         * surface validation (see the note in the README).
          */
         replyMode: z.string().default('auto'),
         /**
@@ -1679,8 +1691,34 @@ export async function attachmentBytes(ctx, sessionId, seq, index) {
 async function stateOf(ctx, sessionId, config) {
   const events = await readEvents(ctx, sessionId)
   if (!events) {
-    noteRequest({ kind: 'state', sessionId, ok: false, code: 'session-not-found' })
-    throw new HttpError(404, 'session-not-found', 'no session log for this id')
+    // A named session with nothing in it yet is an EMPTY session, not a failed
+    // one: the editor opens with nothing to edit, and the next refresh picks the
+    // log up once it exists. Answering 404 here is what the panel printed as
+    // "状态加载失败，稍后重试。". The capability probe still runs, because "what
+    // can this deployment do" does not depend on the log.
+    noteRequest({ kind: 'state', sessionId, ok: true, code: 'session-empty' })
+    const store = resolveAttachmentStore(ctx)
+    return {
+      hidden: [],
+      edits: 0,
+      revisions: [],
+      surface: [],
+      turns: [],
+      replies: [],
+      patches: [],
+      mode: config.patch === true ? 'patch' : 'replay',
+      live: false,
+      busy: false,
+      lastSeq: -1,
+      capabilities: { attachments: store !== null, preview: canPreviewAttachments(store) },
+      config: {
+        confirm: config.confirm,
+        replyMode: config.replyMode,
+        patch: config.patch === true,
+        editorStyle: config.editorStyle,
+      },
+      version: PLUGIN_VERSION,
+    }
   }
   const folded = foldSurface(events)
   const ledger = rollbackLedger(events)
@@ -1868,7 +1906,9 @@ async function applyTargetsEdit(ctx, sessionId, body, config) {
   }
   const events = await readEvents(ctx, sessionId)
   if (!events) throw new HttpError(404, 'session-not-found', 'no session log for this id')
-  if (isBusy(events)) throw new HttpError(409, 'busy', 'the session is still working')
+  // No busy gate here: this path only appends the in-place patch record, which
+  // leaves every surface node where it is. A running turn keeps writing its own
+  // events; the record lands between them and the fold ignores it.
   const surfaceNodes = surfaceOf(ctx, sessionId, events)
   const patches = patchesOf(events)
   const plans = []
@@ -1900,7 +1940,11 @@ async function applyTargetsEdit(ctx, sessionId, body, config) {
       buildPatchData(plans.map(({ plan, text }) => ({ seq: plan.targetSeq, blockIndex: plan.blockIndex, kind: plan.kind, text }))),
     )
   } catch (error) {
-    throw new HttpError(409, 'stale', `the session refused the patch record: ${String((error && error.message) || error)}`)
+    const message = String((error && error.message) || error)
+    if (isProjectionUnavailable(message)) {
+      throw new HttpError(409, 'projection-missing', 'the edit-turn projection is not registered for this session; restart DSH so the owning plugin registers it, then retry')
+    }
+    throw new HttpError(409, 'stale', `the session refused the patch record: ${message}`)
   }
   const flush = await flushSession(ctx, session)
   return {
@@ -1927,22 +1971,23 @@ async function applyEdit(ctx, sessionId, body, config) {
   }
   const events = await readEvents(ctx, sessionId)
   if (!events) throw new HttpError(404, 'session-not-found', 'no session log for this id')
-  if (isBusy(events)) throw new HttpError(409, 'busy', 'the session is still working')
+  const busy = isBusy(events)
 
   const surfaceNodes = surfaceOf(ctx, sessionId, events)
   const patches = patchesOf(events)
   const patchMode = config.patch === true
+  const request = {
+    // A block from another step of the same turn names its own seq; that is
+    // the message the projection has to patch.
+    seq: typeof body.targetSeq === 'number' ? body.targetSeq : typeof body.seq === 'number' ? body.seq : undefined,
+    messageId: typeof body.messageId === 'string' ? body.messageId : undefined,
+    turn: typeof body.turn === 'number' ? body.turn : undefined,
+    blockIndex: typeof body.blockIndex === 'number' ? body.blockIndex : undefined,
+    kind: typeof body.kind === 'string' ? body.kind : undefined,
+  }
   let plan
   try {
-    plan = planRollback(events, surfaceNodes, {
-      // A block from another step of the same turn names its own seq; that is
-      // the message the projection has to patch.
-      seq: typeof body.targetSeq === 'number' ? body.targetSeq : typeof body.seq === 'number' ? body.seq : undefined,
-      messageId: typeof body.messageId === 'string' ? body.messageId : undefined,
-      turn: typeof body.turn === 'number' ? body.turn : undefined,
-      blockIndex: typeof body.blockIndex === 'number' ? body.blockIndex : undefined,
-      kind: typeof body.kind === 'string' ? body.kind : undefined,
-    }, { patches, patch: patchMode })
+    plan = planRollback(events, surfaceNodes, request, { patches, patch: patchMode })
   } catch (error) {
     if (error instanceof EditPlanError) {
       const status = error.code === 'not-editable' ? 400 : 409
@@ -1951,6 +1996,13 @@ async function applyEdit(ctx, sessionId, body, config) {
     throw error
   }
 
+  // A running turn is a hard stop for every path that moves the surface: the
+  // prompt rewrite shadows a message the turn may still be reading, and the
+  // replay splice shadows a window and regenerates the tail. The in-place record
+  // below moves nothing, so it is allowed to land while the agent is still
+  // writing - the model reads it on its next fold.
+  if (busy && plan.patch !== true) throw new HttpError(409, 'busy', 'the session is still working')
+
   // The in-place reply path: one small plugin record, interpreted by this
   // plugin's projection. Nothing leaves the surface, so there is no window to
   // check, no turn to open and no tail to replay. The record is append-only and
@@ -1980,8 +2032,19 @@ async function applyEdit(ctx, sessionId, body, config) {
         buildPatchData([{ seq: plan.targetSeq, blockIndex: plan.blockIndex, kind: plan.kind, text }]),
       )
     } catch (error) {
-      throw new HttpError(409, 'stale', `the session refused the patch record: ${String((error && error.message) || error)}`)
+      const message = String((error && error.message) || error)
+      // The projection is not registered for this session (a live reload that
+      // dropped it). The same edit can land through the replay path, which
+      // needs no projection - so fall through instead of failing the save.
+      if (isProjectionUnavailable(message)) {
+        // The fallback replays the tail, which a running turn forbids.
+        if (busy) throw new HttpError(409, 'busy', 'the session is still working')
+        plan = planRollback(events, surfaceNodes, request, { patches, patch: false })
+      } else {
+        throw new HttpError(409, 'stale', `the session refused the patch record: ${message}`)
+      }
     }
+    if (plan.patch === true) {
     const flush = await flushSession(ctx, session)
     return {
       kind: 'reply',
@@ -1999,6 +2062,7 @@ async function applyEdit(ctx, sessionId, body, config) {
       shadowed: [],
       ...flush,
     }
+    }
   }
 
   // The live surface is the append authority; a node that vanished between the
@@ -2433,10 +2497,85 @@ function requireSessionId(value) {
   return value
 }
 
+/**
+ * Whether the host refused a plugin record because its projection is no longer
+ * registered for this session (a live reload that dropped it, or a session
+ * loaded before the owning plugin). Such a save can still go through the replay
+ * path, so it is not fatal.
+ *
+ * @param message - the host's error text.
+ * @returns true when the record's projection is gone.
+ */
+export function isProjectionUnavailable(message) {
+  return typeof message === 'string' && /projection .*was removed or replaced/i.test(message)
+}
+
 function failure(res, error) {
+  const message = String((error && error.message) || error)
+  // The host refuses to derive a session whose projection left the registry
+  // (`SurfaceManager._assertProjections`). It is a known, self-explaining state
+  // - the plugin was reloaded while that session was open - not an internal
+  // fault, so it answers 409 with the host's own words and does not dump a stack
+  // into the log on every request.
+  if (isProjectionUnavailable(message)) {
+    sendJson(res, 409, { ok: false, code: 'projection-missing', error: message })
+    return
+  }
   const status = error instanceof HttpError ? error.status : 500
   const code = error instanceof HttpError ? error.code : 'internal'
-  sendJson(res, status, { ok: false, code, error: String((error && error.message) || error) })
+  // An unexpected throw is the only case the client cannot explain; leave the
+  // stack in the host log so a report can name the cause.
+  if (!(error instanceof HttpError)) console.error('[dsh-edit-turn] internal error', error)
+  sendJson(res, status, { ok: false, code, error: message })
+}
+
+/**
+ * The one projection object this PROCESS uses, kept across plugin reloads.
+ *
+ * The host registry compares projection IDENTITY, not type:
+ * `SurfaceManager._assertProjections()` (dsh-session/lib/index.js) throws
+ * `session message projection "<type>" was removed or replaced` when a
+ * projection a LIVE session already folded with is no longer in the registry
+ * array, and `registerMessageProjection`'s own docstring states the rule:
+ * "Disposing the contribution makes sessions that used it refuse further
+ * derivation."
+ *
+ * A reload disposes the previous fiber, which splices the old object out of the
+ * registry. Building a fresh object then leaves every open session that carries
+ * a patch event unable to derive anything: the surface read throws, so this
+ * plugin's own save/state paths answer 500, and so does any sibling that reads
+ * `session.surface.nodes` (verified live - dsh-delete-turn's /state answered 500
+ * for such a session after a reload). Reusing one object from a process-global
+ * hands the registry the SAME definition back, so a reloaded plugin keeps the
+ * open sessions foldable.
+ *
+ * The object is a pure, stateless interpreter, which is what makes the reuse
+ * safe. One consequence is deliberate: after a code change the projection keeps
+ * running the PREVIOUS definition for sessions that are already open, until the
+ * session is reopened or DSH restarts. That is the better half of the trade -
+ * the alternative is a session that cannot be read at all.
+ *
+ * @returns the process-wide projection definition.
+ */
+function sharedPatchProjection() {
+  const KEY = '__DSH_EDIT_TURN_PATCH_PROJECTION__'
+  try {
+    const stashed = globalThis[KEY]
+    if (
+      stashed !== undefined &&
+      stashed !== null &&
+      typeof stashed.project === 'function' &&
+      stashed.type === PATCH_TYPE
+    ) {
+      return stashed
+    }
+    const fresh = patchProjection()
+    globalThis[KEY] = fresh
+    return fresh
+  } catch {
+    // A frozen or absent globalThis is not worth failing the load over.
+    return patchProjection()
+  }
 }
 
 // --- plugin ------------------------------------------------------------------
@@ -2477,7 +2616,7 @@ export function apply(ctx, config) {
       const existing = Array.isArray(registry)
         ? registry.find((entry) => entry && entry.type === PATCH_TYPE)
         : undefined
-      if (existing === undefined) sessionsService.registerMessageProjection(patchProjection())
+      if (existing === undefined) sessionsService.registerMessageProjection(sharedPatchProjection())
       patch = true
     } catch (error) {
       if (resolved.replyMode === 'patch') throw error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.5.0",
+  "version": "0.5.3",
   "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",