amalgm 0.1.155 → 0.1.156

package/runtime/scripts/amalgm-mcp/tests/state-shared-replica.test.js

@@ -0,0 +1,283 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-shared-replica-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+process.env.AMALGM_DEVICE_ID = 'device-shared-replica-test';
+process.env.AMALGM_EVENT_LOG_PRUNE_INTERVAL_MS = '0';
+
+const Y = require('yjs');
+const { closeLocalDb } = require('../state/db');
+const docs = require('../state/docs');
+const { listEventsAfter, subscribeStateEvents } = require('../state/events');
+const {
+  acknowledgeCloudMutation,
+  claimCloudMutations,
+  getMutation,
+  journalMutation,
+} = require('../state/mutations');
+const {
+  acknowledgePromotion,
+  claimPromotions,
+  enqueuePromotion,
+} = require('../state/promotions');
+const { getReplicaByResourceId } = require('../state/replicas');
+const {
+  acknowledgeAttachment,
+  claimAttachments,
+  enqueueAttachment,
+} = require('../state/attachments');
+
+const resourceId = 'shr_abcdefghijklmnop';
+const docDir = path.join(tempRoot, 'workspace');
+fs.mkdirSync(docDir, { recursive: true });
+const target = path.join(docDir, 'shared.md');
+fs.writeFileSync(target, '# Shared\n', 'utf8');
+
+function clientFromState(stateBase64) {
+  const doc = new Y.Doc();
+  Y.applyUpdate(doc, new Uint8Array(Buffer.from(stateBase64, 'base64')));
+  return doc;
+}
+
+function captureEdit(doc, mutate) {
+  let captured = null;
+  const listener = (update) => { captured = update; };
+  doc.on('update', listener);
+  mutate(doc.getText('content'));
+  doc.off('update', listener);
+  assert.ok(captured);
+  return Buffer.from(captured).toString('base64');
+}
+
+test.after(() => {
+  docs.closeAllDocs();
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('promotion is durable, idempotent, and installs the runtime-owned cloud binding', () => {
+  const opened = docs.openDoc(target);
+  const queued = enqueuePromotion({
+    promotionId: 'prm_abcdefghijklmnop',
+    resourceId,
+    localResource: opened.resource,
+    localPath: opened.path,
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
+    snapshotBase64: opened.state,
+    contentBytes: fs.statSync(target).size,
+  });
+  assert.equal(queued.duplicate, false);
+  assert.equal(enqueuePromotion({
+    promotionId: 'prm_abcdefghijklmnop',
+    resourceId,
+    localResource: opened.resource,
+    localPath: opened.path,
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
+    snapshotBase64: opened.state,
+    contentBytes: fs.statSync(target).size,
+  }).duplicate, true);
+
+  const claims = claimPromotions();
+  assert.equal(claims.length, 1);
+  assert.equal(claims[0].frame.resourceId, resourceId);
+  assert.equal(claims[0].frame.snapshotChecksum.length, 64);
+
+  const acknowledged = acknowledgePromotion('prm_abcdefghijklmnop', {
+    resourceId,
+    authorityEpoch: 1,
+    headVersion: 0,
+    snapshotVersion: 0,
+    snapshotKey: `shared/${resourceId}/snapshots/v0/${claims[0].frame.snapshotChecksum}.bin`,
+    snapshotChecksum: claims[0].frame.snapshotChecksum,
+  });
+  assert.equal(acknowledged.promotion.state, 'promoted');
+  assert.equal(acknowledgePromotion('prm_abcdefghijklmnop', {
+    resourceId,
+    authorityEpoch: 1,
+    headVersion: 0,
+    snapshotVersion: 0,
+    snapshotKey: acknowledged.promotion.snapshotKey,
+    snapshotChecksum: claims[0].frame.snapshotChecksum,
+  }).duplicate, true);
+
+  const replica = getReplicaByResourceId(resourceId);
+  assert.equal(replica.localPath, target);
+  assert.equal(replica.appliedVersion, 0);
+  assert.equal(replica.contract, 'text-yjs@1');
+});
+
+test('batched surface edits retain separate IDs/versions and recipient file precedes UI event', () => {
+  const opened = docs.openDoc(target);
+  const client = clientFromState(opened.state);
+  const updateA = captureEdit(client, (text) => text.insert(text.length, 'A\n'));
+  const updateB = captureEdit(client, (text) => text.insert(text.length, 'B\n'));
+  const before = listEventsAfter(0).length;
+
+  const local = docs.applyDocMutations(target, [
+    { mutationId: 'mut_shared_batch_001', update: updateA },
+    { mutationId: 'mut_shared_batch_002', update: updateB },
+  ]);
+  assert.equal(local.applied, 2);
+  assert.deepEqual(local.mutationIds, ['mut_shared_batch_001', 'mut_shared_batch_002']);
+  assert.equal(listEventsAfter(0).length, before + 2, 'one projected event per surface edit');
+  assert.equal(fs.readFileSync(target, 'utf8'), '# Shared\nA\nB\n', 'shared file is materialized before return');
+
+  const claims = claimCloudMutations();
+  assert.equal(claims.length, 2, 'one cloud envelope per edit even though transport was batched');
+  assert.deepEqual(claims.map((claim) => claim.envelope.mutationId), [
+    'mut_shared_batch_001',
+    'mut_shared_batch_002',
+  ]);
+  acknowledgeCloudMutation(resourceId, 'mut_shared_batch_001', {
+    version: 1,
+    committedAt: '2026-07-14T20:00:00.000Z',
+  });
+  acknowledgeCloudMutation(resourceId, 'mut_shared_batch_002', {
+    version: 2,
+    committedAt: '2026-07-14T20:00:01.000Z',
+  });
+  assert.equal(getReplicaByResourceId(resourceId).appliedVersion, 2);
+
+  const remoteUpdate = captureEdit(client, (text) => text.insert(text.length, 'Remote\n'));
+  const remoteEnvelope = {
+    resourceId,
+    authorityEpoch: 1,
+    mutationId: 'mut_remote_shared_001',
+    deviceId: 'device-remote-test',
+    baseVersion: 2,
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
+    operationKind: 'yjs.update',
+    operation: { kind: 'yjs.update', update: remoteUpdate },
+  };
+  let observedFile = null;
+  const unsubscribe = subscribeStateEvents((event) => {
+    if (event.mutationId === remoteEnvelope.mutationId) {
+      observedFile = fs.readFileSync(target, 'utf8');
+    }
+  });
+  const remote = docs.applyCloudDocMutation({
+    envelope: remoteEnvelope,
+    version: 3,
+    committedAt: '2026-07-14T20:00:02.000Z',
+  });
+  unsubscribe();
+  assert.equal(remote.mutation.state, 'synced');
+  assert.equal(observedFile, '# Shared\nA\nB\nRemote\n');
+  assert.equal(getReplicaByResourceId(resourceId).appliedVersion, 3);
+
+  const countAfterRemote = listEventsAfter(0).length;
+  assert.equal(docs.applyCloudDocMutation({
+    envelope: remoteEnvelope,
+    version: 3,
+    committedAt: '2026-07-14T20:00:02.000Z',
+  }).duplicate, true);
+  assert.equal(listEventsAfter(0).length, countAfterRemote, 'duplicate cloud delivery is invisible');
+  assert.equal(getMutation(`resource:${resourceId}`, remoteEnvelope.mutationId).officialCloudVersion, 3);
+});
+
+test('a cloud version gap is rejected before file or UI materialization', () => {
+  const opened = docs.openDoc(target);
+  const client = clientFromState(opened.state);
+  const update = captureEdit(client, (text) => text.insert(text.length, 'Gap\n'));
+  const beforeFile = fs.readFileSync(target, 'utf8');
+  const beforeEvents = listEventsAfter(0).length;
+  assert.throws(() => docs.applyCloudDocMutation({
+    envelope: {
+      resourceId,
+      authorityEpoch: 1,
+      mutationId: 'mut_remote_gap_0001',
+      deviceId: 'device-remote-test',
+      baseVersion: 3,
+      contract: 'text-yjs@1',
+      schemaVersion: 1,
+      operationKind: 'yjs.update',
+      operation: { kind: 'yjs.update', update },
+    },
+    version: 5,
+    committedAt: '2026-07-14T20:00:03.000Z',
+  }), /expected 4, received 5/);
+  assert.equal(fs.readFileSync(target, 'utf8'), beforeFile);
+  assert.equal(listEventsAfter(0).length, beforeEvents);
+});
+
+test('reopen recovers a journaled shared edit that died before materialization', () => {
+  const opened = docs.openDoc(target);
+  const client = clientFromState(opened.state);
+  const update = captureEdit(client, (text) => text.insert(text.length, 'Recovered\n'));
+  const mutationId = 'mut_recovery_shared_1';
+  journalMutation({
+    channelId: `resource:${resourceId}`,
+    localResource: opened.resource,
+    sharedResourceId: resourceId,
+    mutationId,
+    deviceId: process.env.AMALGM_DEVICE_ID,
+    authorityEpoch: 1,
+    baseCloudVersion: 3,
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
+    operationKind: 'yjs.update',
+    operation: { kind: 'yjs.update', update },
+  });
+  assert.equal(getMutation(`resource:${resourceId}`, mutationId).state, 'saving-local');
+
+  docs.closeAllDocs();
+  const reopened = docs.openDoc(target);
+  const recovered = clientFromState(reopened.state).getText('content').toString();
+  assert.match(recovered, /Recovered\n$/);
+  assert.match(fs.readFileSync(target, 'utf8'), /Recovered\n$/);
+  assert.equal(getMutation(`resource:${resourceId}`, mutationId).state, 'saved-local');
+  assert.equal(
+    listEventsAfter(0).filter((event) => event.mutationId === mutationId).length,
+    1,
+  );
+});
+
+test('authorized snapshot attachment creates the recipient file before its UI event', () => {
+  const recipientResourceId = 'shr_qrstuvwxyzabcdef';
+  const source = docs.openDoc(target);
+  const recipientPath = path.join(docDir, 'recipient.md');
+  fs.writeFileSync(recipientPath, '', 'utf8');
+  const queued = enqueueAttachment({
+    attachmentId: 'att_abcdefghijklmnop',
+    resourceId: recipientResourceId,
+    localPath: recipientPath,
+  });
+  assert.equal(queued.duplicate, false);
+  assert.equal(claimAttachments().length, 1);
+
+  const snapshot = Buffer.from(source.state, 'base64');
+  const checksum = require('crypto').createHash('sha256').update(snapshot).digest('hex');
+  let observedFile = null;
+  const unsubscribe = subscribeStateEvents((event) => {
+    if (event.sharedResourceId === recipientResourceId && event.source === 'doc:cloud-snapshot') {
+      observedFile = fs.readFileSync(recipientPath, 'utf8');
+    }
+  });
+  const attached = acknowledgeAttachment('att_abcdefghijklmnop', {
+    resourceId: recipientResourceId,
+    authorityEpoch: 1,
+    headVersion: 0,
+    snapshotVersion: 0,
+    snapshotChecksum: checksum,
+    snapshotBase64: source.state,
+    contract: 'text-yjs@1',
+    schemaVersion: 1,
+  });
+  unsubscribe();
+  assert.equal(attached.attachment.state, 'attached');
+  assert.equal(observedFile, fs.readFileSync(target, 'utf8'));
+  assert.equal(fs.readFileSync(recipientPath, 'utf8'), fs.readFileSync(target, 'utf8'));
+  assert.equal(getReplicaByResourceId(recipientResourceId).localPath, recipientPath);
+  assert.equal(acknowledgeAttachment('att_abcdefghijklmnop', {
+    resourceId: recipientResourceId,
+  }).duplicate, true);
+});