amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/workspace/tree/path-state.js

@@ -1,12 +0,0 @@
-'use strict';
-
-/**
- * A pathname has no final entry when either that entry is missing or an
- * ancestor stopped being a directory. Recovery must classify both as
- * absence; the latter is not an I/O failure and must never wedge a WAL.
- */
-function isPathAbsentError(error) {
-  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR';
-}
-
-module.exports = { isPathAbsentError };

package/runtime/scripts/amalgm-mcp/workspace/tree/root-binding.js

@@ -1,125 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { isPathAbsentError } = require('./path-state');
-
-const ROOT_HOLD_REASONS = new Set([
-  'workspace-root-missing',
-  'workspace-root-replaced',
-  'workspace-root-binding-incomplete',
-  'workspace-root-enrollment-pending',
-]);
-
-function physicalDirectory(rootPath) {
-  try {
-    const stats = fs.lstatSync(rootPath);
-    if (!stats.isDirectory() || stats.isSymbolicLink()) return null;
-    return {
-      kind: 'folder',
-      deviceId: String(stats.dev),
-      inode: String(stats.ino),
-      dev: String(stats.dev),
-      ino: String(stats.ino),
-    };
-  } catch (error) {
-    if (isPathAbsentError(error)) return null;
-    throw error;
-  }
-}
-
-function inspectWorkspaceRoot(workspace, database) {
-  const rootPath = path.resolve(workspace?.path || '');
-  const row = workspace?.id
-    ? database.prepare(`
-        SELECT device_id, inode
-        FROM workspace_nodes
-        WHERE workspace_id = ? AND id = ?
-      `).get(workspace.id, workspace.id)
-    : null;
-  const expectedDeviceId = row?.device_id == null ? null : String(row.device_id);
-  const expectedInode = row?.inode == null ? null : String(row.inode);
-  const actual = physicalDirectory(rootPath);
-
-  if ((expectedDeviceId == null) !== (expectedInode == null)) {
-    return {
-      state: 'held',
-      reason: 'workspace-root-binding-incomplete',
-      workspaceId: workspace.id,
-      rootPath,
-      expected: { deviceId: expectedDeviceId, inode: expectedInode },
-      actual,
-    };
-  }
-  if (expectedDeviceId == null) {
-    return {
-      state: 'unbound',
-      workspaceId: workspace.id,
-      rootPath,
-      actual,
-    };
-  }
-  if (!actual) {
-    return {
-      state: 'held',
-      reason: fs.existsSync(rootPath)
-        ? 'workspace-root-replaced'
-        : 'workspace-root-missing',
-      workspaceId: workspace.id,
-      rootPath,
-      expected: { deviceId: expectedDeviceId, inode: expectedInode },
-      actual: null,
-    };
-  }
-  if (
-    actual.deviceId !== expectedDeviceId
-    || actual.inode !== expectedInode
-  ) {
-    return {
-      state: 'held',
-      reason: 'workspace-root-replaced',
-      workspaceId: workspace.id,
-      rootPath,
-      expected: { deviceId: expectedDeviceId, inode: expectedInode },
-      actual,
-    };
-  }
-  return {
-    state: 'verified',
-    workspaceId: workspace.id,
-    rootPath,
-    identity: actual,
-  };
-}
-
-function rootBindingError(proof) {
-  const reason = proof?.reason || (
-    proof?.state === 'unbound'
-      ? 'workspace-root-enrollment-pending'
-      : 'workspace-root-replaced'
-  );
-  return Object.assign(
-    new Error(`workspace tree root is not verified: ${reason}`),
-    {
-      code: 'WORKSPACE_TREE_ROOT_UNVERIFIED',
-      reason,
-      statusCode: 409,
-      paths: proof?.rootPath ? [proof.rootPath] : [],
-      proof,
-    },
-  );
-}
-
-function requireVerifiedWorkspaceRoot(workspace, database) {
-  const proof = inspectWorkspaceRoot(workspace, database);
-  if (proof.state !== 'verified') throw rootBindingError(proof);
-  return proof;
-}
-
-module.exports = {
-  ROOT_HOLD_REASONS,
-  inspectWorkspaceRoot,
-  physicalDirectory,
-  requireVerifiedWorkspaceRoot,
-  rootBindingError,
-};

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

@@ -1,76 +0,0 @@
-'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 };