dsh-session-rewind 1.3.0 → 1.3.1

package/lib/client.js

@@ -66,7 +66,7 @@ loader.load({
     const CUTS_ROUTE = '/api/session-rewind.cuts';
     const DIAGNOSE_ROUTE = '/api/session-rewind.diagnose';
     const TAIL_ROUTE = '/api/session-rewind.tail';
-    const BOOT_REVISION = '1.3.0';
+    const BOOT_REVISION = '1.3.1';
     const HIDDEN_ATTR = 'data-session-rewind-hidden';
 
     /** One per-message bridge per session, shared by every TurnRewind instance. */
@@ -870,6 +870,7 @@ loader.load({
               : `${tr('notice.failed')}（HTTP ${response.status}）`),
           );
           error.status = response.status;
+          error.code = value !== null && typeof value === 'object' && typeof value.code === 'string' ? value.code : null;
           throw error;
         }
         return value;
@@ -949,7 +950,7 @@ loader.load({
         }
       };
 
-      const runRewind = async (seq, restoreFiles, notice) => {
+      const runRewind = async (seq, restoreFiles, notice, fromTurn = null) => {
         notice(tr('notice.working'));
         try {
           const result = await postJson(INPLACE_ROUTE, { sessionId, seq, restoreFiles });
@@ -982,11 +983,24 @@ loader.load({
           }
           notice(parts.length === 0 ? tr('notice.rewound') : `${tr('notice.rewound')} · ${parts.join(' · ')}`);
         } catch (error) {
+          const code = error !== null && typeof error === 'object' ? error.code ?? null : null;
           sendDiagnose(sessionId, {
             reason: 'rewind-failed',
             error: String(error && error.message ? error.message : error),
+            code,
             sequence: seq,
           });
+          if (code === 'not-on-surface') {
+            // Already withdrawn by an earlier rewind: hide the row and say so,
+            // instead of reporting a failure the user cannot act on.
+            const turn = Number.isInteger(fromTurn) ? fromTurn : null;
+            if (Number.isInteger(turn)) {
+              state.hiddenTurns.add(turn);
+              applyHiding();
+            }
+            notice(tr('notice.already'));
+            return;
+          }
           notice(error instanceof Error && error.message !== '' ? error.message : tr('notice.failed'));
         }
       };
@@ -1039,11 +1053,11 @@ loader.load({
         };
         popover.appendChild(makeButton(tr('popover.chat'), () => {
           closePopover();
-          void runRewind(seq, false, notice);
+          void runRewind(seq, false, notice, turn);
         }));
         popover.appendChild(makeButton(tr('popover.both'), () => {
           closePopover();
-          void runRewind(seq, true, notice);
+          void runRewind(seq, true, notice, turn);
         }));
         document.body.appendChild(popover);
         state.popover = popover;

package/locale/en.json

@@ -2,5 +2,6 @@
   "meta": {
     "title": "Session Rewind",
     "description": "Adds a rewind control to every finished Turn plus one entry in the session header. Pick a Turn to branch the conversation there into a new session, put that Turn's original prompt back in the composer so you can edit and resend it, and restore the workspace files that Turn changed to their pre-Turn content."
-  }
+  },
+  "notice.already": "That message was already rewound; its row is now hidden."
 }

package/locale/zh.json

@@ -2,5 +2,6 @@
   "meta": {
     "title": "会话回退",
     "description": "在每个已完成的回合旁加一个回退按钮，并在会话标题栏提供总入口：选中某个回合即可把对话从该回合处分叉成新会话，把该回合原本的输入放回输入框以便修改后重发，同时把该回合改动过的工作区文件恢复到修改前的内容。"
-  }
+  },
+  "notice.already": "这条消息已经回退过了，已从界面隐藏。"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-rewind",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "type": "module",
   "description": "Rewind a finished Turn: branch the conversation at any Turn (session header or per-Turn control) and restore every workspace file that Turn changed. · 回合回退：从任意已完成的回合重新开始，并把该回合改动过的工作区文件恢复原状。",
   "icon": "./icon.svg",

package/src/lib/route.js

@@ -22,6 +22,7 @@ export const INPLACE_PATH = '/api/session-rewind.inplace';
 export const CUTS_PATH = '/api/session-rewind.cuts';
 export const DIAGNOSE_PATH = '/api/session-rewind.diagnose';
 export const TAIL_PATH = '/api/session-rewind.tail';
+export const SURFACE_PATH = '/api/session-rewind.surface';
 export const SELFCHECK_PATH = '/api/session-rewind.selfcheck';
 
 /** A rewind request is a session id plus a Turn number or a seq. */
@@ -199,6 +200,58 @@ function targetOf(value) {
   return { sessionId, turn, seq };
 }
 
+/**
+ * Build the surface route.
+ *
+ * `planInPlace` refuses a rewind when the target Seq is not a node of the live
+ * Session's surface, so when a click is refused the only useful question is what
+ * that surface actually contains. This exposes it read-only.
+ *
+ * @param {{
+ *   surfaceOf: (sessionId: string) => { nodes?: readonly unknown[]; replaceGeneration?: number; contentGeneration?: number } | null,
+ *   trustedHosts?: () => readonly string[],
+ *   onError?: (error: unknown) => void,
+ * }} options
+ * @returns {(request: import('node:http').IncomingMessage, response: import('node:http').ServerResponse) => Promise<void>}
+ */
+export function createSurfaceHandler({ surfaceOf, trustedHosts = () => [], onError = () => {} }) {
+  return async (request, response) => {
+    try {
+      if (request.method !== 'POST') {
+        writeText(response, 405, 'method not allowed');
+        return;
+      }
+      if (!isTrustedRequest(request, hostsOf(trustedHosts))) {
+        writeText(response, 403, 'forbidden');
+        return;
+      }
+      const mediaType = header(request.headers, 'content-type')?.split(';', 1)[0]?.trim().toLowerCase();
+      if (mediaType !== 'application/json') {
+        writeText(response, 415, 'content type must be application/json');
+        return;
+      }
+      const value = await readJsonBody(request);
+      if (!isRecord(value)) throw new RequestBoundaryError(400, 'request body must be a JSON object');
+      const sessionId = typeof value.sessionId === 'string' ? value.sessionId : '';
+      if (sessionId === '') throw new RequestBoundaryError(400, 'sessionId is required');
+      const live = surfaceOf(sessionId);
+      if (live === null) throw new RequestBoundaryError(409, 'this session is not open right now');
+      const nodes = Array.isArray(live.nodes) ? live.nodes.map((node) => (typeof node === 'number' ? node : null)) : [];
+      const tail = Number.isInteger(value.tail) && value.tail > 0 && value.tail <= 200 ? value.tail : 20;
+      writeJson(response, 200, {
+        ok: true,
+        count: nodes.length,
+        replaceGeneration: live.replaceGeneration ?? null,
+        contentGeneration: live.contentGeneration ?? null,
+        head: nodes.slice(0, 10),
+        tail: nodes.slice(-tail),
+      });
+    } catch (error) {
+      fail(response, error, onError);
+    }
+  };
+}
+
 /**
  * Build the event-tail route.
  *

package/src/lib/surface.js

@@ -172,34 +172,38 @@ export function hiddenFromTurn(events) {
 /**
  * Turns whose rows belong to a withdrawn stretch of the log.
  *
- * `hiddenFromSeq` gives the first withdrawn Seq, but the Chat view keys rows by
- * Turn, not Seq — and a plain "turn >= first" rule would also hide the turns the
- * user starts *after* rewinding. The exact set is the turns spanned by the events
- * in `[startSeq, markerSeq)`: everything the marker replaced, and nothing after it.
+ * A Session can be rewound more than once, and each rewind appends its own
+ * marker, so the withdrawn turns are the union over every marker of the turns
+ * spanned by `[surfaceOp.startSeq, markerSeq)`. Taking only the earliest marker —
+ * as the first version did — leaves the turns withdrawn later still on screen.
  *
  * @param {readonly unknown[]} events
  * @returns {readonly number[]}
  */
 export function withdrawnTurns(events) {
-  const startSeq = hiddenFromSeq(events);
-  if (startSeq === null) return [];
-  let markerSeq = null;
+  const spans = [];
   for (const event of events) {
     if (!isRecord(event) || event.type !== 'user/message') continue;
     if (event.data?.source?.kind !== MARKER_SOURCE_KIND) continue;
-    if (typeof event.seq === 'number' && (markerSeq === null || event.seq < markerSeq)) markerSeq = event.seq;
+    if (typeof event.seq !== 'number') continue;
+    const op = event.surfaceOp;
+    if (!isRecord(op) || op.op !== 'replace' || typeof op.startSeq !== 'number') continue;
+    spans.push({ from: op.startSeq, before: event.seq });
   }
-  if (markerSeq === null || markerSeq <= startSeq) return [];
+  if (spans.length === 0) return [];
   const turns = new Set();
   let current = null;
   for (const event of events) {
     if (!isRecord(event) || typeof event.seq !== 'number') continue;
     const turn = event.data?.turn;
-    if (Number.isInteger(turn) && event.type === 'turn/start') current = turn;
-    else if (Number.isInteger(turn) && event.type === 'turn/end') current = turn;
-    if (event.seq < startSeq) continue;
-    if (event.seq >= markerSeq) break;
-    if (Number.isInteger(current)) turns.add(current);
+    if (Number.isInteger(turn) && (event.type === 'turn/start' || event.type === 'turn/end')) current = turn;
+    if (!Number.isInteger(current)) continue;
+    for (const span of spans) {
+      if (event.seq >= span.from && event.seq < span.before) {
+        turns.add(current);
+        break;
+      }
+    }
   }
   return [...turns].sort((left, right) => left - right);
 }

package/src/plugin.js

@@ -29,6 +29,7 @@ import {
   CUTS_PATH,
   DIAGNOSE_PATH,
   INPLACE_PATH,
+  SURFACE_PATH,
   TAIL_PATH,
   PLAN_PATH,
   RESTORE_PATH,
@@ -37,6 +38,7 @@ import {
   createCutsHandler,
   createDiagnoseHandler,
   createInplaceHandler,
+  createSurfaceHandler,
   createTailHandler,
   createPlanHandler,
   createRestoreHandler,
@@ -595,7 +597,7 @@ export function apply(ctx) {
             plugin: 'dsh-session-rewind',
             archive: { directory: archive.directory, ...archiveStats },
             client: { discovered: clientPath !== null, path: clientPath },
-            routes: [SELFCHECK_PATH, DIAGNOSE_PATH, TAIL_PATH, CANDIDATES_PATH, INPLACE_PATH, CUTS_PATH, PLAN_PATH, RESTORE_PATH],
+            routes: [SELFCHECK_PATH, DIAGNOSE_PATH, TAIL_PATH, SURFACE_PATH, CANDIDATES_PATH, INPLACE_PATH, CUTS_PATH, PLAN_PATH, RESTORE_PATH],
           };
         },
         trustedHosts,
@@ -629,6 +631,12 @@ export function apply(ctx) {
         onError,
       });
 
+      const surfaceHandler = createSurfaceHandler({
+        surfaceOf: (sessionId) => liveAgentOf(ctx, sessionId)?.session?.surface ?? null,
+        trustedHosts,
+        onError,
+      });
+
       const tailHandler = createTailHandler({
         events: async (sessionId) => readEvents(ctx, sessionId),
         trustedHosts,
@@ -650,6 +658,10 @@ export function apply(ctx) {
           () => scope.webServer.register({ kind: 'exact', path: SELFCHECK_PATH, handler: statusHandler }),
           'session-rewind: selfcheck route',
         );
+        scope.effect(
+          () => scope.webServer.register({ kind: 'exact', path: SURFACE_PATH, handler: surfaceHandler }),
+          'session-rewind: surface route',
+        );
         scope.effect(
           () => scope.webServer.register({ kind: 'exact', path: TAIL_PATH, handler: tailHandler }),
           'session-rewind: tail route',

package/test/selftest.mjs

@@ -116,6 +116,25 @@ assert.deepEqual(payload.source, { kind: MARKER_SOURCE_KIND });
   assert.deepEqual(withdrawnTurns(events), []);
 }
 
+// --- two rewinds in one Session -------------------------------------------
+// Each marker withdraws its own span; the union is what must disappear. Missing
+// the second marker is what left the later turns on screen.
+{
+  const twice = [
+    { seq: 1, type: 'turn/start', data: { turn: 1 } },
+    { seq: 2, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'one' }] } },
+    { seq: 5, type: 'turn/end', data: { turn: 1 } },
+    { seq: 6, type: 'user/message', data: { source: { kind: MARKER_SOURCE_KIND } }, surfaceOp: { op: 'replace', startSeq: 2, endSeq: 5 } },
+    { seq: 7, type: 'turn/start', data: { turn: 2 } },
+    { seq: 8, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'two' }] } },
+    { seq: 11, type: 'turn/end', data: { turn: 2 } },
+    { seq: 12, type: 'user/message', data: { source: { kind: MARKER_SOURCE_KIND } }, surfaceOp: { op: 'replace', startSeq: 8, endSeq: 11 } },
+    { seq: 13, type: 'turn/start', data: { turn: 3 } },
+    { seq: 14, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'three' }] } },
+  ];
+  assert.deepEqual(withdrawnTurns(twice), [1, 2]);
+}
+
 // --- archive -------------------------------------------------------------
 const root = await mkdtemp(join(tmpdir(), 'rewind-test-'));
 const archiveDir = join(root, 'archive');