amalgm 0.1.161 → 0.1.162

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

@@ -0,0 +1,227 @@
+'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-workspace-tree-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+process.env.AMALGM_WORKSPACES_DIR = path.join(tempRoot, 'workspaces');
+process.env.AMALGM_COMPUTER_ID = 'computer-tree-test';
+fs.mkdirSync(process.env.AMALGM_WORKSPACES_DIR, { recursive: true });
+
+const { closeLocalDb, openLocalDb } = require('../state/db');
+const docs = require('../state/docs');
+const { handleProjectRegister } = require('../workspace/rest');
+const { upsertWorkspace } = require('../workspace/store');
+const {
+  commitPathCreate,
+  commitPathRename,
+  commitTreeOperation,
+  enrollWorkspace,
+  enrollRegisteredWorkspaces,
+  listWorkspaceNodes,
+  nodeForPath,
+  reconcileWorkspaceTree,
+} = require('../workspace/tree-store');
+const { isUuidV7 } = require('../workspace/tree/identity');
+
+test.after(() => {
+  docs.closeAllDocs();
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('enrollment gives every node a UUID and open docs keep one resource through cascaded rename', () => {
+  const root = path.join(process.env.AMALGM_WORKSPACES_DIR, 'project');
+  const folder = path.join(root, 'src');
+  const file = path.join(folder, 'index.js');
+  fs.mkdirSync(folder, { recursive: true });
+  fs.writeFileSync(file, 'export const value = 1;\n');
+  fs.mkdirSync(path.join(root, '.git'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n');
+
+  const workspace = upsertWorkspace({ path: root, name: 'Project', source: 'computer' });
+  assert.equal(isUuidV7(workspace.id), true);
+  const enrolled = enrollWorkspace(workspace.id);
+  assert.equal(enrolled.nodes.length, 3);
+  assert.equal(enrolled.nodes.every((node) => isUuidV7(node.id)), true);
+  assert.equal(enrolled.nodes.some((node) => node.name === '.git'), false);
+
+  const beforeNode = nodeForPath(file).node;
+  const opened = docs.openDoc(file);
+  assert.equal(opened.resource, `doc:${beforeNode.id}`);
+  const renamedFile = path.join(folder, 'main.js');
+  commitPathRename(file, renamedFile);
+  const afterFile = docs.openDoc(renamedFile);
+  assert.equal(afterFile.resource, opened.resource);
+  assert.equal(afterFile.nodeId, beforeNode.id);
+  assert.equal(docs.getDocText(renamedFile), 'export const value = 1;\n');
+
+  const renamedFolder = path.join(root, 'source');
+  commitPathRename(folder, renamedFolder);
+  const cascadedPath = path.join(renamedFolder, 'main.js');
+  assert.equal(fs.existsSync(cascadedPath), true);
+  assert.equal(docs.openDoc(cascadedPath).resource, opened.resource);
+  assert.equal(nodeForPath(cascadedPath).node.id, beforeNode.id);
+
+  const state = openLocalDb().prepare('SELECT path, node_id FROM doc_states WHERE node_id = ?').get(beforeNode.id);
+  assert.equal(state.path, cascadedPath);
+  assert.equal(state.node_id, beforeNode.id);
+});
+
+test('first-update enrollment assigns UUIDs to existing files and ignores nested noise', async () => {
+  const root = path.join(process.env.AMALGM_WORKSPACES_DIR, 'existing-before-update');
+  const repo = path.join(root, 'packages', 'repo');
+  const source = path.join(repo, 'src', 'index.js');
+  const externalRepo = path.join(tempRoot, 'symlink-target-repo');
+  fs.mkdirSync(path.dirname(source), { recursive: true });
+  fs.writeFileSync(source, 'export const ready = true;\n');
+  fs.writeFileSync(path.join(repo, '.env.example'), 'SAFE_EXAMPLE=1\n');
+  fs.writeFileSync(path.join(repo, '.env'), 'SECRET=1\n');
+  fs.mkdirSync(path.join(repo, '.git', 'objects'), { recursive: true });
+  fs.writeFileSync(path.join(repo, '.git', 'HEAD'), 'ref: refs/heads/main\n');
+  fs.mkdirSync(path.join(repo, 'node_modules', 'dependency'), { recursive: true });
+  fs.writeFileSync(path.join(repo, 'node_modules', 'dependency', 'index.js'), 'generated\n');
+  fs.mkdirSync(path.join(repo, '.next', 'cache'), { recursive: true });
+  fs.writeFileSync(path.join(repo, '.next', 'cache', 'data'), 'generated\n');
+  fs.mkdirSync(path.join(repo, '.amalgm', 'reports'), { recursive: true });
+  fs.writeFileSync(path.join(repo, '.amalgm', 'reports', 'run.json'), '{}\n');
+  fs.mkdirSync(path.join(repo, '__pycache__'), { recursive: true });
+  fs.writeFileSync(path.join(repo, '__pycache__', 'module.pyc'), 'generated\n');
+  fs.writeFileSync(path.join(repo, '.DS_Store'), 'generated\n');
+  fs.mkdirSync(externalRepo, { recursive: true });
+  fs.writeFileSync(path.join(externalRepo, 'README.md'), '# Linked repo\n');
+  const linkedRepo = path.join(repo, 'linked-repo');
+  fs.symlinkSync(externalRepo, linkedRepo, 'dir');
+
+  const workspace = upsertWorkspace({ path: root, name: 'Existing before update', source: 'computer' });
+  const database = openLocalDb();
+  assert.equal(
+    database.prepare('SELECT count(*) AS count FROM workspace_nodes WHERE workspace_id = ?').get(workspace.id).count,
+    1,
+  );
+
+  enrollRegisteredWorkspaces({ database });
+  const nodes = listWorkspaceNodes(workspace.id, { database });
+  assert.equal(nodes.every((node) => isUuidV7(node.id)), true);
+  assert.ok(nodes.some((node) => node.relativePath === 'packages/repo/src/index.js'));
+  assert.ok(nodes.some((node) => node.relativePath === 'packages/repo/.env.example'));
+  assert.equal(nodes.some((node) => node.relativePath.includes('/.git/')), false);
+  assert.equal(nodes.some((node) => node.relativePath.includes('/node_modules/')), false);
+  assert.equal(nodes.some((node) => node.relativePath.includes('/.next/')), false);
+  assert.equal(nodes.some((node) => node.relativePath.includes('/.amalgm/')), false);
+  assert.equal(nodes.some((node) => node.relativePath.includes('/__pycache__/')), false);
+  assert.equal(nodes.some((node) => node.relativePath.endsWith('/.env')), false);
+  assert.equal(nodes.some((node) => node.relativePath.endsWith('/.DS_Store')), false);
+
+  const linkNode = nodes.find((node) => node.relativePath === 'packages/repo/linked-repo');
+  assert.equal(linkNode.kind, 'symlink');
+  assert.equal(linkNode.symlinkTarget, externalRepo);
+  assert.equal(nodes.some((node) => node.relativePath.startsWith('packages/repo/linked-repo/')), false);
+
+  let registration;
+  await handleProjectRegister({ path: linkedRepo, name: 'Linked repo' }, (status, body) => {
+    registration = { status, body };
+  });
+  assert.equal(registration.status, 200);
+  assert.equal(registration.body.workspace.path, fs.realpathSync(externalRepo));
+  const linkedNodes = listWorkspaceNodes(registration.body.workspace.id, { database });
+  assert.equal(linkedNodes.every((node) => isUuidV7(node.id)), true);
+  assert.ok(linkedNodes.some((node) => node.relativePath === 'README.md'));
+});
+
+test('trash is editor-class while permanent removal is owner-only', () => {
+  const workspace = openLocalDb().prepare('SELECT * FROM workspaces LIMIT 1').get();
+  const folder = listWorkspaceNodes(workspace.id).find((node) => node.name === 'source');
+  const trashed = commitTreeOperation({
+    kind: 'tree.trash', workspaceId: workspace.id, nodeId: folder.id,
+  }, { role: 'editor' });
+  assert.equal(trashed.operation.kind, 'tree.trash');
+  assert.equal(listWorkspaceNodes(workspace.id).some((node) => node.id === folder.id), false);
+
+  assert.throws(() => commitTreeOperation({
+    kind: 'tree.purge', workspaceId: workspace.id, nodeId: folder.id,
+  }, { role: 'editor' }), /forbidden/);
+  commitTreeOperation({
+    kind: 'tree.purge', workspaceId: workspace.id, nodeId: folder.id,
+  }, { role: 'owner' });
+  const purged = listWorkspaceNodes(workspace.id, { includeTrashed: true, includePurged: true })
+    .find((node) => node.id === folder.id);
+  assert.ok(purged.purgedAt);
+});
+
+test('direct shell creates and renames enter the same UUID tree journal', () => {
+  const root = path.join(process.env.AMALGM_WORKSPACES_DIR, 'observed');
+  fs.mkdirSync(root);
+  const workspace = upsertWorkspace({ path: root, name: 'Observed', source: 'computer' });
+  enrollWorkspace(workspace.id);
+  const firstPath = path.join(root, 'from-shell.txt');
+  fs.writeFileSync(firstPath, 'hello\n');
+  const created = reconcileWorkspaceTree(workspace.id);
+  assert.equal(created.operations.length, 1);
+  assert.equal(created.operations[0].kind, 'tree.create');
+  const nodeId = nodeForPath(firstPath).node.id;
+
+  const secondPath = path.join(root, 'renamed-by-agent.txt');
+  fs.renameSync(firstPath, secondPath);
+  const renamed = reconcileWorkspaceTree(workspace.id);
+  assert.equal(renamed.operations.length, 1);
+  assert.equal(renamed.operations[0].kind, 'tree.rename');
+  assert.equal(nodeForPath(secondPath).node.id, nodeId);
+  const rows = openLocalDb().prepare(`
+    SELECT operation_kind FROM mutation_journal WHERE local_resource = ? ORDER BY journal_id
+  `).all(`workspace-tree:${workspace.id}`);
+  assert.deepEqual(rows.map((row) => row.operation_kind), ['tree.create', 'tree.rename']);
+});
+
+test('recursive create enrolls missing parents without overwriting existing disk entries', () => {
+  const root = path.join(process.env.AMALGM_WORKSPACES_DIR, 'recursive');
+  fs.mkdirSync(root);
+  const workspace = upsertWorkspace({ path: root, name: 'Recursive', source: 'computer' });
+  enrollWorkspace(workspace.id);
+
+  const target = path.join(root, 'one', 'two', 'note.md');
+  commitPathCreate(target, 'file');
+  assert.equal(fs.readFileSync(target, 'utf8'), '');
+  assert.ok(nodeForPath(path.join(root, 'one'))?.node.id);
+  assert.ok(nodeForPath(path.join(root, 'one', 'two'))?.node.id);
+  assert.ok(nodeForPath(target)?.node.id);
+
+  const existing = path.join(root, 'existing.txt');
+  fs.writeFileSync(existing, 'keep me\n');
+  commitPathCreate(existing, 'file');
+  assert.equal(fs.readFileSync(existing, 'utf8'), 'keep me\n');
+  assert.ok(nodeForPath(existing)?.node.id);
+});
+
+test('parent restore leaves an independently trashed child in its own trash slot', () => {
+  const root = path.join(process.env.AMALGM_WORKSPACES_DIR, 'trash-cascades');
+  const folderPath = path.join(root, 'folder');
+  const childPath = path.join(folderPath, 'child.txt');
+  fs.mkdirSync(folderPath, { recursive: true });
+  fs.writeFileSync(childPath, 'child bytes\n');
+  const workspace = upsertWorkspace({ path: root, name: 'Trash cascades', source: 'computer' });
+  enrollWorkspace(workspace.id);
+  const folderId = nodeForPath(folderPath).node.id;
+  const childId = nodeForPath(childPath).node.id;
+  const childTrashPath = path.join(process.env.AMALGM_DIR, 'trash', 'workspaces', workspace.id, childId);
+  const folderTrashPath = path.join(process.env.AMALGM_DIR, 'trash', 'workspaces', workspace.id, folderId);
+
+  commitTreeOperation({ kind: 'tree.trash', workspaceId: workspace.id, nodeId: childId });
+  assert.equal(fs.readFileSync(childTrashPath, 'utf8'), 'child bytes\n');
+  commitTreeOperation({ kind: 'tree.trash', workspaceId: workspace.id, nodeId: folderId });
+  commitTreeOperation({ kind: 'tree.restore', workspaceId: workspace.id, nodeId: folderId });
+  assert.equal(fs.existsSync(folderPath), true);
+  assert.equal(fs.existsSync(childPath), false);
+  assert.equal(fs.existsSync(childTrashPath), true);
+  const child = listWorkspaceNodes(workspace.id, { includeTrashed: true }).find((node) => node.id === childId);
+  assert.ok(child.trashedAt);
+
+  commitTreeOperation({ kind: 'tree.trash', workspaceId: workspace.id, nodeId: folderId });
+  commitTreeOperation({ kind: 'tree.purge', workspaceId: workspace.id, nodeId: folderId });
+  assert.equal(fs.existsSync(folderTrashPath), false);
+  assert.equal(fs.existsSync(childTrashPath), false);
+});

package/runtime/scripts/amalgm-mcp/workspace/access-store.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const { openLocalDb } = require('../state/db');
+const {
+  can,
+  capabilitiesForRole,
+  isRole,
+  resolveEffectiveRole,
+} = require('./tree/access');
+
+function invalid(message, statusCode = 400) {
+  return Object.assign(new Error(message), { statusCode });
+}
+
+function cleanUserId(value, field = 'userId') {
+  const userId = typeof value === 'string' ? value.trim() : '';
+  if (!userId || userId.length > 256) throw invalid(`${field} is required`);
+  return userId;
+}
+
+function nodeRow(database, nodeId) {
+  return database.prepare('SELECT * FROM workspace_nodes WHERE id = ?').get(nodeId) || null;
+}
+
+function workspaceEpoch(workspaceId, options = {}) {
+  const database = options.database || openLocalDb();
+  return Number(database.prepare(`
+    SELECT authority_epoch FROM workspace_access_state WHERE workspace_id = ?
+  `).get(workspaceId)?.authority_epoch || 0);
+}
+
+function bumpEpoch(database, workspaceId) {
+  database.prepare(`
+    INSERT INTO workspace_access_state(workspace_id, authority_epoch, updated_at)
+    VALUES (?, 2, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    ON CONFLICT(workspace_id) DO UPDATE SET
+      authority_epoch = workspace_access_state.authority_epoch + 1,
+      updated_at = excluded.updated_at
+  `).run(workspaceId);
+  return workspaceEpoch(workspaceId, { database });
+}
+
+function explicitPermissions(workspaceId, userId, database) {
+  return database.prepare(`
+    SELECT node_id, role
+    FROM workspace_node_permissions
+    WHERE workspace_id = ? AND user_id = ? AND revoked_at IS NULL
+  `).all(workspaceId, userId);
+}
+
+function resolveAccess(nodeId, userIdInput, options = {}) {
+  const database = options.database || openLocalDb();
+  const userId = cleanUserId(userIdInput);
+  const target = nodeRow(database, nodeId);
+  if (!target || target.purged_at || target.missing_at) return null;
+  const parents = new Map(
+    database.prepare('SELECT id, parent_id FROM workspace_nodes WHERE workspace_id = ?')
+      .all(target.workspace_id)
+      .map((row) => [row.id, row.parent_id || null]),
+  );
+  const roles = new Map(
+    explicitPermissions(target.workspace_id, userId, database)
+      .map((row) => [row.node_id, row.role]),
+  );
+  const role = resolveEffectiveRole(nodeId, parents, roles);
+  return {
+    workspaceId: target.workspace_id,
+    nodeId,
+    userId,
+    role,
+    capabilities: capabilitiesForRole(role),
+    authorityEpoch: workspaceEpoch(target.workspace_id, { database }),
+  };
+}
+
+function requireOwner(database, actorUserId, node) {
+  const access = resolveAccess(node.id, actorUserId, { database });
+  if (!access || !can(access.role, 'manage_access')) throw invalid('only an owner can manage access', 403);
+  return access;
+}
+
+function currentUserRole(nodeId, options = {}) {
+  const actorUserId = require('./identity').userId();
+  if (!actorUserId) return 'owner';
+  return resolveAccess(nodeId, actorUserId, options)?.role || 'no_access';
+}
+
+function setNodePermission(input, options = {}) {
+  const database = options.database || openLocalDb();
+  const node = nodeRow(database, input?.nodeId);
+  if (!node || node.purged_at) throw invalid('node not found', 404);
+  const actorUserId = cleanUserId(input?.actorUserId, 'actorUserId');
+  const userId = cleanUserId(input?.userId);
+  const role = input?.role;
+  if (!isRole(role)) throw invalid('role must be owner, editor, viewer, or no_access');
+  requireOwner(database, actorUserId, node);
+  if (role === 'owner' && node.id !== node.workspace_id) {
+    throw invalid('owner may only be set at the workspace root', 409);
+  }
+  if (userId === actorUserId && role !== 'owner') {
+    throw invalid('an owner cannot lower their own root access', 409);
+  }
+
+  let authorityEpoch;
+  let permissionVersion;
+  database.transaction(() => {
+    database.prepare(`
+      INSERT INTO workspace_node_permissions (
+        workspace_id, node_id, user_id, role, permission_version, revoked_at
+      ) VALUES (?, ?, ?, ?, 1, NULL)
+      ON CONFLICT(node_id, user_id) DO UPDATE SET
+        role = excluded.role,
+        permission_version = workspace_node_permissions.permission_version + 1,
+        revoked_at = NULL,
+        updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+    `).run(node.workspace_id, node.id, userId, role);
+    permissionVersion = Number(database.prepare(`
+      SELECT permission_version FROM workspace_node_permissions
+      WHERE node_id = ? AND user_id = ?
+    `).get(node.id, userId).permission_version);
+    authorityEpoch = bumpEpoch(database, node.workspace_id);
+  })();
+  return { workspaceId: node.workspace_id, nodeId: node.id, userId, role, permissionVersion, authorityEpoch };
+}
+
+function clearNodePermission(input, options = {}) {
+  const database = options.database || openLocalDb();
+  const node = nodeRow(database, input?.nodeId);
+  if (!node) throw invalid('node not found', 404);
+  const actorUserId = cleanUserId(input?.actorUserId, 'actorUserId');
+  const userId = cleanUserId(input?.userId);
+  requireOwner(database, actorUserId, node);
+
+  let authorityEpoch;
+  const changed = database.transaction(() => {
+    const result = database.prepare(`
+      UPDATE workspace_node_permissions
+      SET revoked_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'),
+          permission_version = permission_version + 1,
+          updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+      WHERE node_id = ? AND user_id = ? AND revoked_at IS NULL AND role <> 'owner'
+    `).run(node.id, userId);
+    if (result.changes) authorityEpoch = bumpEpoch(database, node.workspace_id);
+    return result.changes > 0;
+  })();
+  return { workspaceId: node.workspace_id, nodeId: node.id, userId, changed, authorityEpoch: authorityEpoch || workspaceEpoch(node.workspace_id, { database }) };
+}
+
+/** Remove every active grant for one user and bump the workspace epoch once. */
+function revokeWorkspaceUser(input, options = {}) {
+  const database = options.database || openLocalDb();
+  const workspaceId = input?.workspaceId;
+  const root = nodeRow(database, workspaceId);
+  if (!root || root.id !== root.workspace_id) throw invalid('workspace not found', 404);
+  const actorUserId = cleanUserId(input?.actorUserId, 'actorUserId');
+  const userId = cleanUserId(input?.userId);
+  requireOwner(database, actorUserId, root);
+  if (userId === actorUserId) throw invalid('the workspace owner cannot be revoked', 409);
+
+  let authorityEpoch;
+  const revoked = database.transaction(() => {
+    const result = database.prepare(`
+      UPDATE workspace_node_permissions
+      SET revoked_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now'),
+          permission_version = permission_version + 1,
+          updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+      WHERE workspace_id = ? AND user_id = ? AND revoked_at IS NULL AND role <> 'owner'
+    `).run(workspaceId, userId);
+    if (result.changes) authorityEpoch = bumpEpoch(database, workspaceId);
+    return result.changes;
+  })();
+  return { workspaceId, userId, revoked, authorityEpoch: authorityEpoch || workspaceEpoch(workspaceId, { database }) };
+}
+
+module.exports = {
+  clearNodePermission,
+  currentUserRole,
+  resolveAccess,
+  revokeWorkspaceUser,
+  setNodePermission,
+  workspaceEpoch,
+};

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

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * One step of binding a local file to a derived-id shared resource,
+ * modeled on the machine wall's proven attach/promote cycle. Callers run
+ * it from their own periodic reconcile until it reports bound — each call
+ * advances the durable attachment request by at most one move, so a
+ * binding survives restarts and offline stretches for free.
+ *
+ * Owners pass `create: true`: when the cloud has never heard of the id,
+ * the empty local file is promoted into existence (exactly one create
+ * wins a race; the loser's next attach finds the resource existing).
+ * Readers of a peer's resource keep `create` off and simply retry the
+ * attach until the owner's create lands.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ATTACH_REJECTED = /shared_resource_read_forbidden/;
+
+/** Adapt a shared-rest handler (which speaks sendJson) into a promise. */
+function callLocal(handler, body) {
+  return new Promise((resolve, reject) => {
+    handler(body, (status, payload) => {
+      if (status >= 400) reject(new Error(payload?.error || `local shared route failed with ${status}`));
+      else resolve(payload);
+    });
+  });
+}
+
+async function ensureDocBound({ resourceId, filePath, create = false }) {
+  if (require('../state/replicas').getReplicaByResourceId(resourceId)) {
+    return { bound: true, state: 'bound', lastError: null };
+  }
+  const shared = require('../state/shared-rest');
+  const attachments = require('../state/attachments');
+
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, '');
+
+  const request = attachments.getAttachmentByResource(resourceId);
+  if (!request) {
+    await callLocal(shared.handleAttachmentStart, { resourceId, path: filePath });
+    return { bound: false, state: 'attaching', lastError: null };
+  }
+  if (request.state === 'rejected') {
+    if (
+      create
+      && ATTACH_REJECTED.test(request.lastError || '')
+      && !require('../state/promotions').getPromotionByResource(resourceId)
+    ) {
+      await callLocal(shared.handlePromotionStart, { resourceId, path: filePath });
+      return { bound: false, state: 'creating', lastError: request.lastError };
+    }
+    attachments.retryAttachment(resourceId);
+    return { bound: false, state: 'retrying', lastError: request.lastError };
+  }
+  return { bound: false, state: request.state, lastError: request.lastError || null };
+}
+
+module.exports = { ensureDocBound };