amalgm 0.1.238 → 0.1.240

package/runtime/scripts/amalgm-mcp/tests/workspace-tree-core.test.js

@@ -6,6 +6,7 @@ const assert = require('node:assert/strict');
 const { can, resolveEffectiveRole } = require('../workspace/tree/access');
 const { isUuidV7, uuidV7, uuidV7Timestamp } = require('../workspace/tree/identity');
 const { applyTreeOperation } = require('../workspace/tree/reducer');
+const { normalizeTreeSnapshot } = require('../workspace/tree/snapshot');
 
 test('UUIDv7 identity is standard, timestamped, and independent of path', () => {
   const now = 1_782_000_123_456;
@@ -70,6 +71,82 @@ test('tree operations preserve identity across rename and reject cycles', () =>
   }), /destination folder does not exist|inside itself/);
 });
 
+test('symlink legality is a portable invariant of the complete live tree', () => {
+  const workspaceId = uuidV7();
+  const folderId = uuidV7();
+  const nestedId = uuidV7();
+  const linkId = uuidV7();
+  const root = {
+    id: workspaceId,
+    workspaceId,
+    parentId: null,
+    kind: 'folder',
+    name: 'Workspace',
+  };
+  let nodes = new Map([[workspaceId, root]]);
+  nodes = applyTreeOperation(nodes, {
+    kind: 'tree.create',
+    workspaceId,
+    nodeId: folderId,
+    parentId: workspaceId,
+    nodeKind: 'folder',
+    name: 'folder',
+  });
+  nodes = applyTreeOperation(nodes, {
+    kind: 'tree.create',
+    workspaceId,
+    nodeId: nestedId,
+    parentId: folderId,
+    nodeKind: 'folder',
+    name: 'nested',
+  });
+  nodes = applyTreeOperation(nodes, {
+    kind: 'tree.create',
+    workspaceId,
+    nodeId: linkId,
+    parentId: nestedId,
+    nodeKind: 'symlink',
+    name: 'entry',
+    symlinkTarget: '../../folder/file.txt',
+  });
+
+  assert.throws(() => applyTreeOperation(nodes, {
+    kind: 'tree.move',
+    workspaceId,
+    nodeId: nestedId,
+    parentId: workspaceId,
+  }), /escapes its workspace/);
+  for (const [index, target] of [
+    '../../../outside',
+    '/tmp/outside',
+    '\\\\server\\share',
+    'C:\\outside',
+    'C:outside',
+  ].entries()) {
+    assert.throws(() => applyTreeOperation(nodes, {
+      kind: 'tree.create',
+      workspaceId,
+      nodeId: uuidV7(Date.now() + index),
+      parentId: workspaceId,
+      nodeKind: 'symlink',
+      name: `unsafe-${index}`,
+      symlinkTarget: target,
+    }), /relative|escapes its workspace/);
+  }
+
+  const snapshot = {
+    schemaVersion: 1,
+    workspaceId,
+    version: 0,
+    nodes: Array.from(nodes.values()).map((node) => ({ ...node })),
+  };
+  snapshot.nodes.find((node) => node.id === linkId).symlinkTarget = '../../../outside';
+  assert.throws(
+    () => normalizeTreeSnapshot(snapshot),
+    /escapes its workspace/,
+  );
+});
+
 test('trash cascades preserve independently trashed children', () => {
   const workspaceId = uuidV7();
   const folderId = uuidV7();
@@ -99,9 +176,11 @@ test('trash cascades preserve independently trashed children', () => {
     kind: 'tree.trash', workspaceId, nodeId: fileId, trashedAt: '2026-07-21T00:01:00.000Z',
   });
   nodes = applyTreeOperation(nodes, {
-    kind: 'tree.trash', workspaceId, nodeId: folderId, trashedAt: '2026-07-21T00:02:00.000Z',
+    kind: 'tree.trash', workspaceId, nodeId: folderId, trashedAt: '2026-07-21T00:01:00.000Z',
   });
   assert.equal(nodes.get(fileId).trashedAt, '2026-07-21T00:01:00.000Z');
+  assert.equal(nodes.get(fileId).trashComponentId, fileId);
+  assert.equal(nodes.get(folderId).trashComponentId, folderId);
 
   nodes = applyTreeOperation(nodes, {
     kind: 'tree.restore', workspaceId, nodeId: folderId,
@@ -111,4 +190,115 @@ test('trash cascades preserve independently trashed children', () => {
   assert.throws(() => applyTreeOperation(nodes, {
     kind: 'tree.restore', workspaceId, nodeId: folderId,
   }), /must be trashed/);
+
+  nodes = applyTreeOperation(nodes, {
+    kind: 'tree.purge', workspaceId, nodeId: fileId,
+  });
+  assert.ok(nodes.get(fileId).purgedAt);
+  assert.equal(nodes.get(fileId).trashComponentId, null);
+});
+
+test('snapshots require active trash provenance and retire it on purge', () => {
+  const workspaceId = uuidV7();
+  const fileId = uuidV7();
+  const base = {
+    schemaVersion: 1,
+    workspaceId,
+    version: 1,
+    nodes: [
+      {
+        id: workspaceId,
+        workspaceId,
+        parentId: null,
+        kind: 'folder',
+        name: 'Workspace',
+      },
+      {
+        id: fileId,
+        workspaceId,
+        parentId: workspaceId,
+        kind: 'file',
+        name: 'note.txt',
+        trashedAt: '2026-07-21T00:01:00.000Z',
+      },
+    ],
+  };
+  assert.throws(
+    () => normalizeTreeSnapshot(base),
+    /requires explicit trash provenance/,
+  );
+  const cyclic = structuredClone(base);
+  cyclic.nodes[1].trashedAt = null;
+  cyclic.nodes[1].parentId = fileId;
+  assert.throws(() => normalizeTreeSnapshot(cyclic), /contains a cycle/);
+
+  const siblingId = uuidV7();
+  const nonAncestor = structuredClone(base);
+  nonAncestor.nodes.push({
+    id: siblingId,
+    workspaceId,
+    parentId: workspaceId,
+    kind: 'folder',
+    name: 'other-trash',
+    trashedAt: '2026-07-21T00:01:00.000Z',
+    trashComponentId: siblingId,
+  });
+  nonAncestor.nodes[1].trashComponentId = siblingId;
+  assert.throws(() => normalizeTreeSnapshot(nonAncestor), /is not an ancestor/);
+
+  const purged = structuredClone(base);
+  purged.nodes[1].purgedAt = '2026-07-21T00:02:00.000Z';
+  const normalized = normalizeTreeSnapshot(purged);
+  assert.equal(normalized.nodes.get(fileId).trashComponentId, null);
+});
+
+test('snapshot ancestry validation stays bounded on a deep tree', { timeout: 10_000 }, () => {
+  const workspaceId = uuidV7();
+  const componentId = uuidV7();
+  const changedAt = '2026-07-21T00:01:00.000Z';
+  const nodes = [{
+    id: workspaceId,
+    workspaceId,
+    parentId: null,
+    kind: 'folder',
+    name: 'Workspace',
+  }, {
+    id: componentId,
+    workspaceId,
+    parentId: workspaceId,
+    kind: 'folder',
+    name: 'trash-root',
+  }];
+  let parentId = componentId;
+  for (let index = 0; index < 20_000; index += 1) {
+    const id = uuidV7();
+    nodes.push({
+      id,
+      workspaceId,
+      parentId,
+      kind: 'folder',
+      name: `level-${index}`,
+    });
+    parentId = id;
+  }
+  const live = normalizeTreeSnapshot({
+    schemaVersion: 1,
+    workspaceId,
+    version: 1,
+    nodes,
+  });
+  const trashed = applyTreeOperation(live.nodes, {
+    kind: 'tree.trash',
+    workspaceId,
+    nodeId: componentId,
+    trashedAt: changedAt,
+  });
+  const normalized = normalizeTreeSnapshot({
+    schemaVersion: 1,
+    workspaceId,
+    version: 2,
+    nodes: Array.from(trashed.values()),
+  });
+  assert.equal(normalized.nodes.size, nodes.length);
+  assert.equal(normalized.nodes.get(parentId).trashComponentId, componentId);
 });