amalgm 0.1.239 → 0.1.241

package/runtime/scripts/amalgm-mcp/workspace/tree/snapshot.js

@@ -2,6 +2,7 @@
 
 const { isUuid } = require('./identity');
 const { KINDS, normalizeNodeName } = require('./operations');
+const { validateLiveSymlinkTargets } = require('./symlinks');
 
 function invalid(message) {
   throw Object.assign(new Error(message), { statusCode: 400 });
@@ -35,6 +36,12 @@ function normalizeTreeSnapshot(input) {
     }
     const parentId = value.parentId == null ? null : String(value.parentId).toLowerCase();
     if (parentId && !isUuid(parentId)) invalid('workspace tree parent identity is invalid');
+    const trashComponentId = value.trashComponentId == null
+      ? null
+      : String(value.trashComponentId).toLowerCase();
+    if (trashComponentId && !isUuid(trashComponentId)) {
+      invalid('workspace tree trash component identity is invalid');
+    }
     const createdAt = timestamp(value.createdAt, new Date().toISOString());
     const updatedAt = timestamp(value.updatedAt, createdAt);
     if (value.kind === 'symlink' && (typeof value.symlinkTarget !== 'string' || !value.symlinkTarget)) {
@@ -48,6 +55,7 @@ function normalizeTreeSnapshot(input) {
       name: normalizeNodeName(value.name),
       symlinkTarget: value.kind === 'symlink' ? value.symlinkTarget : null,
       trashedAt: value.trashedAt ? timestamp(value.trashedAt) : null,
+      trashComponentId,
       purgedAt: value.purgedAt ? timestamp(value.purgedAt) : null,
       createdAt,
       updatedAt,
@@ -58,17 +66,30 @@ function normalizeTreeSnapshot(input) {
   if (!root || root.parentId !== null || root.kind !== 'folder') {
     invalid('workspace tree requires one folder root whose id is the workspace id');
   }
+  const ancestry = buildAncestryIndex(nodes, workspaceId);
   const siblingNames = new Set();
   for (const node of nodes.values()) {
     if (node.id === workspaceId) continue;
-    if (!node.parentId || !nodes.has(node.parentId)) invalid('workspace tree node parent is missing');
-    const seen = new Set([node.id]);
-    let current = node;
-    while (current.parentId) {
-      if (seen.has(current.parentId)) invalid('workspace tree contains a cycle');
-      seen.add(current.parentId);
-      current = nodes.get(current.parentId);
-      if (!current) invalid('workspace tree node parent is missing');
+    if (node.purgedAt) {
+      if (node.trashComponentId) {
+        invalid('a purged workspace tree node cannot name a physical trash component');
+      }
+    } else if (node.trashedAt) {
+      if (!node.trashComponentId) {
+        invalid('an active workspace tree tombstone requires explicit trash provenance');
+      }
+      const component = nodes.get(node.trashComponentId);
+      if (
+        !component
+        || !component.trashedAt
+        || component.purgedAt
+        || component.trashComponentId !== component.id
+        || !isAncestor(ancestry, component.id, node.id)
+      ) {
+        invalid('workspace tree trash component is not an ancestor');
+      }
+    } else if (node.trashComponentId) {
+      invalid('a live workspace tree node cannot name a trash component');
     }
     if (!node.trashedAt && !node.purgedAt) {
       const key = `${node.parentId}\0${node.name}`;
@@ -76,7 +97,57 @@ function normalizeTreeSnapshot(input) {
       siblingNames.add(key);
     }
   }
+  validateLiveSymlinkTargets(nodes, workspaceId);
   return { schemaVersion: 1, workspaceId, version: input.version, nodes };
 }
 
+function buildAncestryIndex(nodes, rootId) {
+  const children = new Map();
+  for (const node of nodes.values()) {
+    if (node.id === rootId) continue;
+    if (!node.parentId || !nodes.has(node.parentId)) invalid('workspace tree node parent is missing');
+    const siblings = children.get(node.parentId) || [];
+    siblings.push(node.id);
+    children.set(node.parentId, siblings);
+  }
+
+  const entered = new Map();
+  const exited = new Map();
+  const stack = [{ id: rootId, exit: false }];
+  let clock = 0;
+  while (stack.length) {
+    const frame = stack.pop();
+    if (frame.exit) {
+      exited.set(frame.id, clock);
+      clock += 1;
+      continue;
+    }
+    if (entered.has(frame.id)) invalid('workspace tree contains a cycle');
+    entered.set(frame.id, clock);
+    clock += 1;
+    stack.push({ id: frame.id, exit: true });
+    const descendants = children.get(frame.id) || [];
+    for (let index = descendants.length - 1; index >= 0; index -= 1) {
+      stack.push({ id: descendants[index], exit: false });
+    }
+  }
+  if (entered.size !== nodes.size) invalid('workspace tree contains a cycle');
+  return { entered, exited };
+}
+
+function isAncestor(index, ancestorId, nodeId) {
+  const ancestorEntered = index.entered.get(ancestorId);
+  const ancestorExited = index.exited.get(ancestorId);
+  const nodeEntered = index.entered.get(nodeId);
+  const nodeExited = index.exited.get(nodeId);
+  return (
+    ancestorEntered !== undefined
+    && ancestorExited !== undefined
+    && nodeEntered !== undefined
+    && nodeExited !== undefined
+    && ancestorEntered <= nodeEntered
+    && nodeExited <= ancestorExited
+  );
+}
+
 module.exports = { normalizeTreeSnapshot };

package/runtime/scripts/amalgm-mcp/workspace/tree/symlinks.js

@@ -0,0 +1,76 @@
+'use strict';
+
+function invalidSymlink(node, message) {
+  throw Object.assign(new Error(message), {
+    code: 'WORKSPACE_TREE_SYMLINK_ESCAPE',
+    reason: 'symlink-escapes-workspace',
+    statusCode: 409,
+    nodeId: node?.id || null,
+  });
+}
+
+function portableTargetSegments(target, node) {
+  if (
+    typeof target !== 'string'
+    || !target
+    || target.includes('\0')
+    || /^[\\/]/.test(target)
+    || /^[A-Za-z]:/.test(target)
+  ) {
+    invalidSymlink(node, 'workspace tree symlink target must be relative');
+  }
+  return target.split(/[\\/]+/);
+}
+
+function liveNode(node) {
+  return Boolean(node && !node.trashedAt && !node.purgedAt);
+}
+
+function logicalParentSegments(nodes, rootId, node) {
+  const segments = [];
+  const seen = new Set([node.id]);
+  let currentId = node.parentId;
+  while (currentId && currentId !== rootId) {
+    if (seen.has(currentId)) {
+      invalidSymlink(node, 'workspace tree symlink ancestry contains a cycle');
+    }
+    seen.add(currentId);
+    const current = nodes.get(currentId);
+    if (!current) {
+      invalidSymlink(node, 'workspace tree symlink parent is missing');
+    }
+    segments.push(current.name);
+    currentId = current.parentId;
+  }
+  if (currentId !== rootId) {
+    invalidSymlink(node, 'workspace tree symlink is outside its workspace');
+  }
+  return segments.reverse();
+}
+
+function validateLiveSymlinkTargets(inputNodes, rootId) {
+  const nodes = inputNodes instanceof Map
+    ? inputNodes
+    : new Map((inputNodes || []).map((node) => [node.id, node]));
+  for (const node of nodes.values()) {
+    if (node.kind !== 'symlink' || !liveNode(node)) continue;
+    const resolved = logicalParentSegments(nodes, rootId, node);
+    for (const segment of portableTargetSegments(node.symlinkTarget, node)) {
+      if (!segment || segment === '.') continue;
+      if (segment === '..') {
+        if (!resolved.length) {
+          invalidSymlink(
+            node,
+            `workspace tree symlink ${node.id} escapes its workspace`,
+          );
+        }
+        resolved.pop();
+      } else {
+        resolved.push(segment);
+      }
+    }
+  }
+  return nodes;
+}
+
+module.exports = { validateLiveSymlinkTargets };