dsh-session-rewind 0.0.0-stage → 1.2.8

package/test/route-smoke.mjs

@@ -0,0 +1,272 @@
+/**
+ * Route-level test: the two Host routes through their real fences and shape,
+ * with a real archive and a stubbed Turn lookup.
+ */
+
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { createArchive } from '../src/lib/archive.js';
+import {
+  CANDIDATES_PATH,
+  PLAN_PATH,
+  RESTORE_PATH,
+  createCandidatesHandler,
+  createCutsHandler,
+  createInplaceHandler,
+  createPlanHandler,
+  createRestoreHandler,
+} from '../src/lib/route.js';
+
+const root = await mkdtemp(join(tmpdir(), 'rewind-route-'));
+const archive = createArchive({ directory: join(root, 'archive') });
+const file = join(root, 'src', 'main.ts');
+const { mkdir } = await import('node:fs/promises');
+await mkdir(join(root, 'src'), { recursive: true });
+await writeFile(file, 'const a = 1;\n', 'utf8');
+
+const sessionId = 'session-route-1';
+await archive.record({ sessionId, turn: 2, absolute: file, displayPath: 'src/main.ts' });
+
+const describeTurn = async (id, options) => {
+  if (id !== sessionId) return null;
+  const turn = Number.isInteger(options.turn) ? options.turn : 2;
+  if (turn !== 2) return null;
+  return { turn, endSeq: 41 };
+};
+
+const restored = [];
+const planHandler = createPlanHandler({
+  archive,
+  describeTurn,
+  userPromptOf: async () => 'make it dark',
+  trustedHosts: () => [],
+});
+const restoreHandler = createRestoreHandler({
+  archive,
+  describeTurn,
+  restoreFile: async (entry) => {
+    restored.push(entry.path);
+    return { path: entry.displayPath, status: 'restored' };
+  },
+  trustedHosts: () => [],
+});
+
+const HOST = '127.0.0.1:64031';
+
+function request(body, options = {}) {
+  const text = body === undefined ? '' : JSON.stringify(body);
+  return {
+    method: options.method ?? 'POST',
+    headers: {
+      host: options.host ?? HOST,
+      origin: options.origin ?? (options.host === undefined ? `http://${HOST}` : options.origin),
+      'content-type': options.contentType ?? 'application/json',
+      ...(options.headers ?? {}),
+    },
+    async *[Symbol.asyncIterator]() {
+      if (text !== '') yield Buffer.from(text, 'utf8');
+    },
+  };
+}
+
+function response() {
+  return {
+    status: 0,
+    headers: {},
+    body: '',
+    writeHead(status, headers) {
+      this.status = status;
+      this.headers = headers ?? {};
+    },
+    end(text) {
+      this.body = text ?? '';
+    },
+  };
+}
+
+// --- plan ----------------------------------------------------------------
+let res = response();
+await planHandler(request({ sessionId, turn: 2 }), res);
+assert.equal(res.status, 200);
+const plan = JSON.parse(res.body);
+assert.deepEqual(plan, {
+  ok: true,
+  turn: 2,
+  seq: 41,
+  prompt: 'make it dark',
+  files: [{ path: file, displayPath: 'src/main.ts', action: 'restore', size: 13 }],
+});
+assert.equal(res.headers['Cache-Control'], 'no-store');
+assert.equal(res.headers['X-Content-Type-Options'], 'nosniff');
+
+// seq-only targeting works too
+res = response();
+await planHandler(request({ sessionId, seq: 40 }), res);
+assert.equal(res.status, 200);
+
+// --- plan gates ----------------------------------------------------------
+res = response();
+await planHandler(request({ sessionId, turn: 2 }, { method: 'GET' }), res);
+assert.equal(res.status, 405);
+
+res = response();
+await planHandler(request({ sessionId, turn: 2 }, { host: 'example.com', origin: 'http://example.com' }), res);
+assert.equal(res.status, 403);
+
+res = response();
+await planHandler(request({ sessionId, turn: 2 }, { headers: { 'sec-fetch-site': 'cross-site' } }), res);
+assert.equal(res.status, 403);
+
+res = response();
+await planHandler(request({ sessionId, turn: 2 }, { origin: 'http://evil.example' }), res);
+assert.equal(res.status, 403);
+
+res = response();
+await planHandler(request({ sessionId, turn: 2 }, { contentType: 'text/plain' }), res);
+assert.equal(res.status, 415);
+
+res = response();
+await planHandler(request({ sessionId: '' }), res);
+assert.equal(res.status, 400);
+
+res = response();
+await planHandler(request({ sessionId }), res);
+assert.equal(res.status, 400);
+
+res = response();
+await planHandler(request({ sessionId: 'other', turn: 2 }), res);
+assert.equal(res.status, 409);
+
+// --- candidates ----------------------------------------------------------
+const listTurns = async (id, limit) => {
+  if (id !== sessionId) return [];
+  return [{ turn: 2, seq: 41, prompt: 'make it dark', files: { count: 1, restorable: 1 } }].slice(0, limit);
+};
+const candidatesHandler = createCandidatesHandler({ listTurns, trustedHosts: () => [] });
+
+res = response();
+await candidatesHandler(request({ sessionId }), res);
+assert.equal(res.status, 200);
+assert.deepEqual(JSON.parse(res.body), {
+  ok: true,
+  turns: [{ turn: 2, seq: 41, prompt: 'make it dark', files: { count: 1, restorable: 1 } }],
+});
+
+res = response();
+await candidatesHandler(request({ sessionId }, { method: 'GET' }), res);
+assert.equal(res.status, 405);
+
+res = response();
+await candidatesHandler(request({ sessionId: 'x' }), res);
+assert.equal(res.status, 200);
+assert.deepEqual(JSON.parse(res.body).turns, []);
+
+res = response();
+await candidatesHandler(request({}), res);
+assert.equal(res.status, 400);
+
+res = response();
+await candidatesHandler(request({ sessionId }, { host: 'example.com', origin: 'http://example.com' }), res);
+assert.equal(res.status, 403);
+
+// --- in-place rewind ----------------------------------------------------
+const executed = [];
+const inplaceHandler = createInplaceHandler({
+  describe: async (id, seq) => {
+    if (id !== sessionId) throw Object.assign(new Error('not live'), { status: 409 });
+    if (seq !== 11) throw Object.assign(new Error('only your own messages'), { code: 'not-a-user-message' });
+    return { targetSeq: 11, surfaceStart: 11, surfaceEnd: 41, prompt: 'make it dark', turn: 2 };
+  },
+  execute: async (id, seq, restoreFiles) => {
+    if (seq !== 11) throw Object.assign(new Error('only your own messages'), { code: 'not-a-user-message' });
+    executed.push({ id, seq, restoreFiles });
+    return { markerSeq: 50, targetSeq: seq, prompt: 'make it dark', turn: 2, hiddenFromSeq: 11, hiddenFromTurn: 2 };
+  },
+  trustedHosts: () => [],
+});
+
+// dryRun plans without executing
+res = response();
+await inplaceHandler(request({ sessionId, seq: 11, dryRun: true }), res);
+assert.equal(res.status, 200);
+assert.equal(JSON.parse(res.body).dryRun, true);
+assert.deepEqual(executed, []);
+
+// execute appends + reports the cut
+res = response();
+await inplaceHandler(request({ sessionId, seq: 11 }), res);
+assert.equal(res.status, 200);
+assert.deepEqual(JSON.parse(res.body), {
+  ok: true, markerSeq: 50, targetSeq: 11, prompt: 'make it dark', turn: 2, hiddenFromSeq: 11, hiddenFromTurn: 2,
+});
+assert.deepEqual(executed, [{ id: sessionId, seq: 11, restoreFiles: true }]);
+
+// a planning refusal is a 409 with a code, not a 500
+executed.length = 0;
+res = response();
+await inplaceHandler(request({ sessionId, seq: 12 }), res);
+assert.equal(res.status, 409);
+assert.equal(JSON.parse(res.body).code, 'not-a-user-message');
+
+// gates
+res = response();
+await inplaceHandler(request({ sessionId }, {}), res);
+assert.equal(res.status, 400);
+res = response();
+await inplaceHandler(request({ sessionId, seq: -1 }), res);
+assert.equal(res.status, 400);
+res = response();
+await inplaceHandler(request({ sessionId, seq: 11 }, { host: 'evil.example', origin: 'http://evil.example' }), res);
+assert.equal(res.status, 403);
+
+// --- cuts ----------------------------------------------------------------
+const cutsHandler = createCutsHandler({
+  cutsOf: async (id) => (id === sessionId ? { hiddenFromSeq: 11, hiddenFromTurn: 2 } : { hiddenFromSeq: null, hiddenFromTurn: null }),
+  trustedHosts: () => [],
+});
+res = response();
+await cutsHandler(request({ sessionId }), res);
+assert.equal(res.status, 200);
+assert.deepEqual(JSON.parse(res.body), { ok: true, hiddenFromSeq: 11, hiddenFromTurn: 2 });
+res = response();
+await cutsHandler(request({}), res);
+assert.equal(res.status, 400);
+
+// --- restore -------------------------------------------------------------
+res = response();
+await restoreHandler(request({ sessionId, turn: 2 }), res);
+assert.equal(res.status, 200);
+assert.deepEqual(JSON.parse(res.body), {
+  ok: true,
+  turn: 2,
+  results: [{ path: 'src/main.ts', status: 'restored' }],
+});
+assert.deepEqual(restored, [file]);
+
+// a client cannot name a path that the archive did not record
+restored.length = 0;
+res = response();
+await restoreHandler(request({ sessionId, turn: 2, paths: ['C:/Windows/System32/config/SAM'] }), res);
+assert.equal(res.status, 200);
+assert.deepEqual(JSON.parse(res.body).results, []);
+assert.deepEqual(restored, []);
+
+// an unknown turn is refused, and no file is touched
+restored.length = 0;
+res = response();
+await restoreHandler(request({ sessionId, turn: 9 }), res);
+assert.equal(res.status, 409);
+assert.deepEqual(restored, []);
+
+// a Turn with no captured files answers with an empty result, not an error
+res = response();
+await restoreHandler(request({ sessionId, turn: 2, paths: [] }), res);
+assert.equal(res.status, 200);
+
+console.log(`route smoke: all assertions passed (${PLAN_PATH}, ${RESTORE_PATH})`);
+
+await archive.close();
+await rm(root, { recursive: true, force: true });

package/test/selftest.mjs

@@ -0,0 +1,262 @@
+/**
+ * Self-test for the Host half's pure logic: Turn location, prompt extraction,
+ * the durable archive, and the per-file restorer. Runs outside the plugin
+ * package so nothing here ships.
+ */
+
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, stat as fsStat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { isInsideGitMetadata, createArchive } from '../src/lib/archive.js';
+import { restoreFile } from '../src/lib/restore.js';
+import { locateTurn, userPromptOf } from '../src/plugin.js';
+import {
+  MARKER_SOURCE_KIND,
+  MARKER_TEXT,
+  hiddenFromSeq,
+  hiddenFromTurn,
+  listCandidates,
+  markerPayload,
+  planInPlace,
+} from '../src/lib/surface.js';
+
+const events = [
+  { seq: 0, type: 'session', data: {} },
+  { seq: 1, type: 'turn/start', data: { turn: 1 } },
+  { seq: 2, type: 'user/message', data: { source: { kind: 'runtime-context' }, content: [{ type: 'text', text: 'runtime noise' }] } },
+  { seq: 3, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'first prompt' }] } },
+  { seq: 4, type: 'tool/call', data: { turn: 1 } },
+  { seq: 5, type: 'turn/end', data: { turn: 1, reason: { kind: 'completed' } } },
+  { seq: 6, type: 'turn/start', data: { turn: 2 } },
+  { seq: 7, type: 'user/message', data: { source: { kind: 'user' }, content: [{ type: 'text', text: 'second prompt' }, { type: 'text', text: 'with two blocks' }] } },
+  { seq: 9, type: 'turn/end', data: { turn: 2, reason: { kind: 'completed' } } },
+];
+
+// --- turn location -------------------------------------------------------
+assert.deepEqual(locateTurn(events, { turn: 1 }), { turn: 1, endSeq: 5 });
+assert.deepEqual(locateTurn(events, { turn: 2 }), { turn: 2, endSeq: 9 });
+// The client sends the closing message seq when the Turn object has no `end`.
+assert.deepEqual(locateTurn(events, { seq: 8 }), { turn: 2, endSeq: 9 });
+assert.deepEqual(locateTurn(events, { seq: 4 }), { turn: 1, endSeq: 5 });
+assert.equal(locateTurn(events, { turn: 7 }), null);
+assert.equal(locateTurn(events, {}), null);
+
+// --- prompt extraction ---------------------------------------------------
+assert.equal(userPromptOf(events, 1), 'first prompt');
+assert.equal(userPromptOf(events, 2), 'second prompt\nwith two blocks');
+assert.equal(userPromptOf(events, 3), null);
+
+// --- in-place surface planning ------------------------------------------
+const surface = [0, 3, 4, 5, 7, 8, 9];
+assert.deepEqual(planInPlace(events, surface, 3), {
+  targetSeq: 3,
+  surfaceStart: 3,
+  surfaceEnd: 9,
+  shadowedSeqs: [3, 4, 5, 7, 8, 9],
+});
+assert.deepEqual(planInPlace(events, surface, 7).shadowedSeqs, [7, 8, 9]);
+assert.throws(() => planInPlace(events, surface, 2), (error) => error.code === 'not-a-user-message');
+assert.throws(() => planInPlace(events, surface, 999), (error) => error.code === 'not-a-user-message');
+assert.throws(() => planInPlace(events, surface, 0), (error) => error.code === 'not-a-user-message');
+// a user message removed from the surface by compaction is not rewritable
+assert.throws(() => planInPlace(events, [4, 5, 7, 8, 9], 3), (error) => error.code === 'not-on-surface');
+assert.throws(() => planInPlace(events, [], 3), (error) => error.code === 'no-user-messages');
+
+const listed = listCandidates(events, surface);
+assert.deepEqual(listed.map((item) => item.seq), [7, 3]);
+assert.deepEqual(listed.map((item) => item.index), [1, 2]);
+assert.equal(listed[0].preview, ['second prompt', 'with two blocks'].join(String.fromCharCode(10)));
+
+// no marker yet: nothing hidden
+assert.equal(hiddenFromSeq(events), null);
+assert.equal(hiddenFromTurn(events), null);
+
+const marker = (seq, startSeq) => ({
+  seq,
+  type: 'user/message',
+  data: { source: { kind: MARKER_SOURCE_KIND }, content: [{ type: 'text', text: MARKER_TEXT }] },
+  surfaceOp: { op: 'replace', startSeq, endSeq: 9 },
+});
+const afterRewind = [...events, marker(10, 7)];
+assert.equal(hiddenFromSeq(afterRewind), 7);
+assert.equal(hiddenFromTurn(afterRewind), 2);
+// an older cut wins over a newer one, and a non-plugin message never counts
+const olderCut = [...afterRewind, marker(11, 3)];
+assert.equal(hiddenFromSeq(olderCut), 3);
+assert.equal(hiddenFromTurn(olderCut), 1);
+assert.equal(hiddenFromSeq([...events, { seq: 10, type: 'user/message', data: { source: { kind: 'user' }, content: [] } }]), null);
+
+const payload = markerPayload((seed) => `id:${seed}`);
+assert.equal(payload.role, 'user');
+assert.match(payload.id, /^id:session-rewind-\d+$/u);
+assert.equal(payload.content[0].text, MARKER_TEXT);
+assert.notEqual(payload.content[0].text, '');
+assert.deepEqual(payload.source, { kind: MARKER_SOURCE_KIND });
+
+// --- archive -------------------------------------------------------------
+const root = await mkdtemp(join(tmpdir(), 'rewind-test-'));
+const archiveDir = join(root, 'archive');
+const workDir = join(root, 'work');
+await mkdir(workDir, { recursive: true });
+
+const existing = join(workDir, 'app.js');
+const binary = join(workDir, 'logo.bin');
+const created = join(workDir, 'new.txt');
+await writeFile(existing, 'const before = 1;\n', 'utf8');
+await writeFile(binary, Buffer.from([0, 1, 2, 255, 0]), 'binary');
+
+const warnings = [];
+const archive = createArchive({ directory: archiveDir, warn: (error) => warnings.push(error) });
+const sessionId = 'session-test-1';
+
+const capturedExisting = await archive.record({
+  sessionId, turn: 1, cwd: workDir, absolute: existing, displayPath: 'app.js',
+});
+assert.equal(capturedExisting.existed, true);
+assert.equal(capturedExisting.text, true);
+assert.equal(typeof capturedExisting.blob, 'string');
+
+const capturedBinary = await archive.record({
+  sessionId, turn: 1, cwd: workDir, absolute: binary, displayPath: 'logo.bin',
+});
+assert.equal(capturedBinary.existed, true);
+assert.equal(capturedBinary.text, false);
+
+const capturedCreated = await archive.record({
+  sessionId, turn: 1, cwd: workDir, absolute: created, displayPath: 'new.txt',
+});
+assert.equal(capturedCreated.existed, false);
+assert.equal(capturedCreated.blob, null);
+
+// dedupe inside one Turn, and .git is never recorded
+assert.equal(await archive.record({ sessionId, turn: 1, absolute: existing, displayPath: 'app.js' }), null);
+assert.equal(await archive.record({
+  sessionId, turn: 1, absolute: join(workDir, '.git', 'HEAD'), displayPath: '.git/HEAD',
+}), null);
+assert.equal(isInsideGitMetadata(join(workDir, '.git', 'HEAD')), true);
+assert.equal(isInsideGitMetadata(join(workDir, 'git', 'HEAD')), false);
+assert.equal(isInsideGitMetadata(join(workDir, '.gitignore')), false);
+assert.equal(isInsideGitMetadata(join(workDir, 'src', 'app.js')), false);
+
+const entry = await archive.get(sessionId, 1);
+assert.equal(entry.files.length, 3);
+assert.deepEqual(await archive.readBlob(capturedExisting.blob), Buffer.from('const before = 1;\n'));
+assert.deepEqual(await archive.readBlob(capturedBinary.blob), Buffer.from([0, 1, 2, 255, 0]));
+assert.equal(await archive.readBlob('../../etc/passwd'), null);
+assert.equal(await archive.get('nobody', 1), null);
+await archive.markRestored(sessionId, 1);
+assert.equal(typeof (await archive.get(sessionId, 1)).restoredAt, 'number');
+await archive.close();
+
+// persistence across a reload
+const reopened = createArchive({ directory: archiveDir });
+assert.equal((await reopened.get(sessionId, 1)).files.length, 3);
+await reopened.close();
+assert.equal(warnings.length, 0, `unexpected warnings: ${warnings.map(String).join(', ')}`);
+
+// --- restore -------------------------------------------------------------
+const archive2 = createArchive({ directory: join(root, 'archive2') });
+const fsWrites = [];
+const fsService = {
+  resolve: async (path) => ({ targetKey: path, displayPath: path }),
+  contains: (parent, child) => child.targetKey === parent.targetKey
+    || child.targetKey.startsWith(`${parent.targetKey}\\`)
+    || child.targetKey.startsWith(`${parent.targetKey}/`),
+  stat: async (target) => {
+    try {
+      await fsStat(target.targetKey);
+      return { version: 'v-current', type: 'file', size: 1 };
+    } catch {
+      return undefined;
+    }
+  },
+  writeText: async (target, content, expected, signal, policy) => {
+    fsWrites.push({ target: target.targetKey, content, expected, policy });
+    await writeFile(target.targetKey, content, 'utf8');
+  },
+};
+
+const before = await archive2.record({
+  sessionId: 's2', turn: 4, absolute: existing, displayPath: 'app.js',
+});
+await writeFile(existing, 'const after = 2;\n', 'utf8');
+const restored = await restoreFile({ fsService, archive: archive2, file: before, workspaceRoot: workDir });
+assert.deepEqual(restored, { path: 'app.js', status: 'restored' });
+assert.equal(await readFile(existing, 'utf8'), 'const before = 1;\n');
+assert.deepEqual(fsWrites[0].expected, { kind: 'replaceIfVersion', version: 'v-current' });
+// A plugin-originated write needs an explicit policy; inside the Turn's own
+// workspace the narrower mode is used.
+assert.deepEqual(fsWrites[0].policy, { mode: 'workspace-write', workspaceRoot: workDir });
+
+// Outside that workspace the restore has to use the wider mode.
+const outside = join(root, 'outside.txt');
+await writeFile(outside, 'outside before\n', 'utf8');
+const outsideRecord = await archive2.record({ sessionId: 's2', turn: 4, absolute: outside, displayPath: 'outside.txt' });
+fsWrites.length = 0;
+await restoreFile({ fsService, archive: archive2, file: outsideRecord, workspaceRoot: workDir });
+assert.deepEqual(fsWrites[0].policy, { mode: 'danger-full-access', workspaceRoot: workDir });
+
+// absent pre-image -> createIfAbsent
+fsWrites.length = 0;
+await rm(existing, { force: true });
+const missingTarget = await restoreFile({ fsService, archive: archive2, file: before });
+assert.deepEqual(missingTarget, { path: 'app.js', status: 'restored' });
+assert.deepEqual(fsWrites[0].expected, { kind: 'createIfAbsent' });
+
+// binary pre-image bypasses the text path and writes exact bytes
+await writeFile(binary, Buffer.from([9, 9, 9]), 'binary');
+const binBefore = await archive2.record({ sessionId: 's2', turn: 4, absolute: binary, displayPath: 'logo.bin' });
+await writeFile(binary, Buffer.from([7, 7]), 'binary');
+await restoreFile({ fsService, archive: archive2, file: binBefore });
+assert.deepEqual([...await readFile(binary)], [9, 9, 9]);
+
+// a file the Turn created is removed
+const createdFile = join(workDir, 'made.txt');
+const madeRecord = await archive2.record({ sessionId: 's2', turn: 4, absolute: createdFile, displayPath: 'made.txt' });
+assert.equal(madeRecord.existed, false);
+await writeFile(createdFile, 'made\n', 'utf8');
+const observations = [];
+const removed = await restoreFile({
+  fsService,
+  archive: archive2,
+  file: madeRecord,
+  workspaceRoot: workDir,
+  syncObservation: async (absolute, observation) => observations.push({ absolute, observation }),
+});
+assert.deepEqual(removed, { path: 'made.txt', status: 'deleted' });
+await assert.rejects(readFile(createdFile, 'utf8'), (error) => error.code === 'ENOENT');
+// The removal is published as an observation so DSH's fs policy does not keep
+// believing the file still exists.
+assert.deepEqual(observations, [{ absolute: createdFile, observation: { kind: 'absent' } }]);
+
+// A binary restore publishes the re-read version as a present observation.
+// (NUL/0xFF bytes so the pre-image is genuinely not UTF-8.)
+await writeFile(binary, Buffer.from([0, 255, 1]), 'binary');
+const binBefore2 = await archive2.record({ sessionId: 's2', turn: 5, absolute: binary, displayPath: 'logo.bin' });
+assert.equal(binBefore2.text, false);
+await writeFile(binary, Buffer.from([6, 6]), 'binary');
+const binaryObservations = [];
+await restoreFile({
+  fsService,
+  archive: archive2,
+  file: binBefore2,
+  workspaceRoot: workDir,
+  syncObservation: async (absolute, observation) => binaryObservations.push({ absolute, observation }),
+});
+assert.deepEqual([...await readFile(binary)], [0, 255, 1]);
+assert.deepEqual(binaryObservations, [{ absolute: binary, observation: { kind: 'present', version: 'v-current' } }]);
+
+// a pruned/absent blob is reported, never guessed
+const goneBlob = await restoreFile({
+  fsService,
+  archive: { readBlob: async () => null },
+  file: { ...before, blob: 'a'.repeat(64) + '.bin' },
+});
+assert.equal(goneBlob.status, 'skipped');
+
+await archive2.close();
+await rm(root, { recursive: true, force: true });
+
+console.log('selftest: all assertions passed');