dsh-ferry 0.1.1 → 0.1.3

package/lib/ferry.js

@@ -285,6 +285,7 @@ export function createFerry({ ctx, config, transfer, log = () => {} }) {
             {
               sessionId,
               eventCount: description.session.eventCount,
+              conversationCount: description.session.conversationCount,
               createdAt: description.session.createdAt,
               formatVersion: description.session.formatVersion,
               sourceRoot: description.session.cwd,
@@ -362,6 +363,7 @@ export function createFerry({ ctx, config, transfer, log = () => {} }) {
         // With a fresh id, an id collision on the peer is not a conflict.
         sessionId: forkId ? undefined : sessionId,
         eventCount: description.session.eventCount,
+        conversationCount: description.session.conversationCount,
         createdAt: description.session.createdAt,
         formatVersion: description.session.formatVersion,
         // No target means the receiver applies its own mapping: reuse the
@@ -463,6 +465,7 @@ export function createFerry({ ctx, config, transfer, log = () => {} }) {
     const local = await transfer.preflight({
       sessionId,
       eventCount: description.session.eventCount,
+      conversationCount: description.session.conversationCount,
       createdAt: description.session.createdAt,
       formatVersion: description.session.formatVersion,
       sourceRoot: description.session.cwd,
@@ -513,6 +516,7 @@ export function createFerry({ ctx, config, transfer, log = () => {} }) {
     const local = await transfer.preflight({
       sessionId: forkId ? undefined : sessionId,
       eventCount: description.session.eventCount,
+      conversationCount: description.session.conversationCount,
       createdAt: description.session.createdAt,
       formatVersion: description.session.formatVersion,
       targetDir,

package/lib/routes.js

@@ -106,6 +106,7 @@ export function createPeerHandler({ config, ferry, transfer, log = () => {} }) {
           const decision = await transfer.preflight({
             sessionId: typeof body.sessionId === 'string' ? body.sessionId : undefined,
             eventCount: typeof body.eventCount === 'number' ? body.eventCount : undefined,
+            conversationCount: typeof body.conversationCount === 'number' ? body.conversationCount : undefined,
             createdAt: typeof body.createdAt === 'number' ? body.createdAt : undefined,
             formatVersion: typeof body.formatVersion === 'number' ? body.formatVersion : undefined,
             sourceRoot: typeof body.sourceRoot === 'string' ? body.sourceRoot : undefined,

package/lib/state.js

@@ -10,6 +10,20 @@
  */
 import { createHash } from 'node:crypto';
 
+/**
+ * Payload fields that hold a sequence number pointing at another event. They
+ * move when a log is renumbered, so they are compared as "a reference exists"
+ * rather than by value.
+ */
+const SEQ_REFERENCE_KEYS = new Set([
+  'headerSeq',
+  'sourceEventSeq',
+  'sourceEventSeqs',
+  'messageSeqs',
+  'shadowedSeqs',
+  'shadowedRange',
+]);
+
 /** Number of trailing events that make up a tail fingerprint. */
 export const TAIL_EVENTS = 8;
 
@@ -63,7 +77,10 @@ function updateHash(hash, value) {
   for (const key of Object.keys(record).sort()) {
     hash.update(JSON.stringify(key));
     hash.update(':');
-    updateHash(hash, record[key]);
+    // Sequence references are derived positions, not content: an append that
+    // renumbers its tail must not read as a different conversation.
+    if (SEQ_REFERENCE_KEYS.has(key)) hash.update('"#seq"');
+    else updateHash(hash, record[key]);
     hash.update(',');
   }
   hash.update('}');
@@ -121,11 +138,15 @@ export function conversationEvents(events) {
  * @returns {object} event as compared.
  */
 function comparableEvent(event) {
-  if (event !== null && typeof event === 'object' && event.type === 'session/end-seed' && 'time' in event) {
-    const { time: _time, ...rest } = event;
-    return rest;
+  if (event === null || typeof event !== 'object') return event;
+  // Position is the array index; the stored number moves when a tail is
+  // renumbered onto a peer's log, so it must not decide equality.
+  const { seq: _seq, ...rest } = event;
+  if (rest.type === 'session/end-seed' && 'time' in rest) {
+    const { time: _time, ...withoutTime } = rest;
+    return withoutTime;
   }
-  return event;
+  return rest;
 }
 
 /**

package/lib/transfer.js

@@ -276,6 +276,7 @@ export function createTransfer({ ctx, config, rules, log = () => {} }) {
     }
     const records = await ctx.sessionPersistence.list({ signal });
     const children = records.filter((record) => record.header.parentSession === sessionId).length;
+    const conversation = conversationEvents(snapshot.events);
     return {
       session: {
         sessionId,
@@ -283,7 +284,8 @@ export function createTransfer({ ctx, config, rules, log = () => {} }) {
         cwd: header.cwd,
         createdAt: header.createdAt,
         eventCount: snapshot.events.length,
-        tail: tailOf(snapshot.events),
+        conversationCount: conversation.length,
+        tail: tailOf(conversation),
         inheritedEventCount: snapshot.inheritedEventCount,
         origin: header.origin,
         agentPreset: header.agentPreset,
@@ -442,7 +444,8 @@ export function createTransfer({ ctx, config, rules, log = () => {} }) {
         header,
         inheritedEventCount: snapshot.inheritedEventCount,
         eventCount: snapshot.events.length,
-        tail: tailOf(snapshot.events),
+        conversationCount: conversationEvents(snapshot.events).length,
+        tail: tailOf(conversationEvents(snapshot.events)),
         lastSeq: snapshot.events.at(-1)?.seq ?? -1,
         agentPreset: header.agentPreset,
         origin: header.origin,
@@ -504,9 +507,15 @@ export function createTransfer({ ctx, config, rules, log = () => {} }) {
       );
     }
     const local = await readSnapshot(sessionId, signal);
-    const remoteCount = typeof sourceSession.eventCount === 'number' ? sourceSession.eventCount : undefined;
+    const mine = conversationEvents(local.events);
+    const remoteCount =
+      typeof sourceSession.conversationCount === 'number'
+        ? sourceSession.conversationCount
+        : typeof sourceSession.eventCount === 'number'
+          ? sourceSession.eventCount
+          : undefined;
     const state = classifySession(
-      { count: local.events.length, tail: tailOf(local.events) },
+      { count: mine.length, tail: tailOf(mine) },
       { count: remoteCount, tail: readTail(sourceSession.tail) },
     );
     if (state === 'same') return { mode: update ? 'update' : 'exists', snapshot: local };
@@ -751,6 +760,19 @@ export function createTransfer({ ctx, config, rules, log = () => {} }) {
       workspaceId = workspace.id;
       if (plan.mode === 'update') {
         const shared = appendFrom;
+        // The receiver may hold more events than the sender at the same
+        // conversation position (it wrote its own runtime markers), so the
+        // appended batch is renumbered to continue the receiver's log.
+        const local = /** @type {{ events: object[] }} */ (plan.snapshot);
+        const sourceEvents = sessionPayload.events;
+        const nextSeq = local.events.length;
+        const delta = nextSeq - (sourceEvents[shared]?.seq ?? shared);
+        const tail = sourceEvents.slice(shared).map((event, index) => {
+          const seq = nextSeq + index;
+          return seq === event.seq ? event : renumberEvent(event, seq, delta, shared);
+        });
+        // A mismatch here would write a log the receiver can never open again.
+        assertTailReferences([...local.events, ...tail], nextSeq);
         let handle;
         try {
           handle = await ctx.sessionPersistence.open(sessionId, 'write', { signal });
@@ -767,10 +789,9 @@ export function createTransfer({ ctx, config, rules, log = () => {} }) {
           throw error;
         }
         try {
-          const events = sessionPayload.events;
-          for (let offset = shared; offset < events.length; offset += 200) {
+          for (let offset = 0; offset < tail.length; offset += 200) {
             signal?.throwIfAborted();
-            await handle.append(events.slice(offset, offset + 200), { signal });
+            await handle.append(tail.slice(offset, offset + 200), { signal });
           }
           await handle.flush({ signal });
         } finally {
@@ -792,7 +813,7 @@ export function createTransfer({ ctx, config, rules, log = () => {} }) {
           sessionId,
           targetDir: target,
           workspaceId,
-          appended: sessionPayload.events.length - shared,
+          appended: tail.length,
           events: sessionPayload.events.length,
           attachments: { rewritten: attachmentReplacements.size },
           workspace: {
@@ -886,6 +907,7 @@ export function createTransfer({ ctx, config, rules, log = () => {} }) {
     targetDir,
     merge = false,
     tail,
+    conversationCount,
   }) => {
     const target = await resolveImportTarget({ requested: targetDir, sourceRoot, sessionId });
     const currentVersion = await currentFormatVersion();
@@ -923,10 +945,14 @@ export function createTransfer({ ctx, config, rules, log = () => {} }) {
             }`,
           };
         }
-        localCount = snapshot.events.length;
+        const conversation = conversationEvents(snapshot.events);
+        localCount = conversation.length;
         state = classifySession(
-          { count: localCount, tail: tailOf(snapshot.events) },
-          { count: eventCount, tail: readTail(tail) },
+          { count: localCount, tail: tailOf(conversation) },
+          {
+            count: typeof conversationCount === 'number' ? conversationCount : eventCount,
+            tail: readTail(tail),
+          },
         );
         if (state === 'unknown') {
           // A sender predating tail fingerprints only reports its creation time.
@@ -990,6 +1016,93 @@ async function* once(buffer) {
   if (buffer !== undefined && buffer.length > 0) yield buffer;
 }
 
+/**
+ * Check that the references inside a renumbered tail still resolve.
+ *
+ * The stored format validates a few of them on open (`headerSeq` must point at
+ * a request header, `messageSeqs` at human messages). A field this plugin does
+ * not know about cannot be checked, so the known ones are verified before the
+ * write rather than after it.
+ * @param {readonly object[]} events - the receiver's log with the tail appended.
+ * @param {number} from - index of the first appended event.
+ * @throws {HttpError} when a reference would not resolve on the receiver.
+ */
+function assertTailReferences(events, from) {
+  for (let index = from; index < events.length; index += 1) {
+    const data = events[index].data;
+    if (data === null || typeof data !== 'object') continue;
+    const headerSeq = data.headerSeq;
+    if (Number.isSafeInteger(headerSeq) && events[headerSeq]?.type !== 'request/header') {
+      throw new HttpError(
+        409,
+        'session-reference-mismatch',
+        `Cannot renumber this session: event ${events[index].seq} references request header ${headerSeq}, which would not exist`,
+      );
+    }
+    const messageSeqs = data.messageSeqs;
+    if (Array.isArray(messageSeqs)) {
+      for (const seq of messageSeqs) {
+        if (events[seq]?.type !== 'user/message') {
+          throw new HttpError(
+            409,
+            'session-reference-mismatch',
+            `Cannot renumber this session: event ${events[index].seq} references message ${seq}, which would not be a user message`,
+          );
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Rewrite one event for a log that numbers the same content differently.
+ * @param {object} event - source event.
+ * @param {number} seq - sequence number it takes in the receiver's log.
+ * @param {number} delta - shift applied to the receiver-relative numbering.
+ * @param {number} from - first sender seq that belongs to the shifted tail.
+ * @returns {object} renumbered event.
+ */
+function renumberEvent(event, seq, delta, from) {
+  const next = { ...event, seq };
+  if (event.data !== null && typeof event.data === 'object') {
+    next.data = shiftSeqRefs(event.data, delta, from);
+  }
+  return next;
+}
+
+/**
+ * Shift the sequence references a payload may hold into the receiver's numbering.
+ * @param {unknown} value - payload value.
+ * @param {number} delta - shift for references inside the moved tail.
+ * @param {number} from - first sender seq that belongs to the moved tail.
+ * @returns {unknown} rewritten value.
+ */
+function shiftSeqRefs(value, delta, from) {
+  if (Array.isArray(value)) return value.map((item) => shiftSeqRefs(item, delta, from));
+  if (value === null || typeof value !== 'object') return value;
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    if ((key === 'headerSeq' || key === 'sourceEventSeq') && Number.isSafeInteger(item) && item >= from) {
+      out[key] = item + delta;
+      continue;
+    }
+    if ((key === 'shadowedSeqs' || key === 'messageSeqs' || key === 'sourceEventSeqs') && Array.isArray(item)) {
+      out[key] = item.map((entry) => (Number.isSafeInteger(entry) && entry >= from ? entry + delta : entry));
+      continue;
+    }
+    if (key === 'shadowedRange' && item !== null && typeof item === 'object') {
+      out[key] = {
+        ...item,
+        ...(Number.isSafeInteger(item.start) && item.start >= from ? { start: item.start + delta } : {}),
+        ...(Number.isSafeInteger(item.end) && item.end >= from ? { end: item.end + delta } : {}),
+      };
+      continue;
+    }
+    out[key] = shiftSeqRefs(item, delta, from);
+  }
+  return out;
+}
+
 /**
  * Raw index in the incoming log where the receiver's new events begin.
  * @param {readonly object[]} incoming - incoming session events.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ferry",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "Move Sessions and their Workspace between DSH instances over any reachable network.",
   "license": "MIT",