amalgm 0.1.161 → 0.1.162

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

@@ -0,0 +1,391 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { AMALGM_DIR } = require('../config');
+const { openLocalDb } = require('../state/db');
+const { applyTreeOperation } = require('./tree/reducer');
+const { relativeWorkspacePath, shouldSync } = require('./tree/inclusion');
+const { normalizeTreeOperation } = require('./tree/operations');
+const { normalizeTreeSnapshot } = require('./tree/snapshot');
+const {
+  hasAncestorInSet,
+  materializeOperation,
+  persistNodes,
+  rowToNode,
+  workspaceRow,
+} = require('./tree/local-state');
+
+const TREE_RESOURCE_PREFIX = 'workspace-tree:';
+
+function invalid(message, statusCode = 400) {
+  return Object.assign(new Error(message), { statusCode });
+}
+
+function localTree() {
+  return require('./tree-store');
+}
+
+function workspaceTreeSnapshot(workspaceId, options = {}) {
+  const database = options.database || openLocalDb();
+  const nodes = localTree().listWorkspaceNodes(workspaceId, {
+    database,
+    includeTrashed: true,
+    includePurged: true,
+  }).filter((node) => node.id === workspaceId || shouldSync(node.relativePath));
+  return { schemaVersion: 1, workspaceId, version: 0, nodes };
+}
+
+function decodeTreeSnapshot(input) {
+  if (typeof input?.snapshotBase64 !== 'string' || !input.snapshotBase64) {
+    throw invalid('snapshotBase64 is required');
+  }
+  const bytes = Buffer.from(input.snapshotBase64, 'base64');
+  const checksum = crypto.createHash('sha256').update(bytes).digest('hex');
+  if (checksum !== input.snapshotChecksum) throw invalid('snapshot checksum mismatch', 409);
+  let parsed;
+  try {
+    parsed = JSON.parse(bytes.toString('utf8'));
+  } catch {
+    throw invalid('workspace tree snapshot must be JSON');
+  }
+  return { bytes, checksum, snapshot: normalizeTreeSnapshot(parsed) };
+}
+
+function pathMapForSnapshot(snapshot) {
+  const paths = new Map([[snapshot.workspaceId, '']]);
+  const visit = (nodeId) => {
+    if (paths.has(nodeId)) return paths.get(nodeId);
+    const node = snapshot.nodes.get(nodeId);
+    if (!node) throw invalid('workspace tree node is missing', 409);
+    const parentPath = visit(node.parentId);
+    const relativePath = parentPath ? `${parentPath}/${node.name}` : node.name;
+    paths.set(nodeId, relativePath);
+    return relativePath;
+  };
+  for (const node of snapshot.nodes.values()) visit(node.id);
+  return paths;
+}
+
+function safeSymlinkTarget(rootPath, linkPath, target) {
+  if (path.isAbsolute(target)) return false;
+  const resolved = path.resolve(path.dirname(linkPath), target);
+  return relativeWorkspacePath(rootPath, resolved) != null;
+}
+
+function activeNode(node) {
+  return Boolean(node && !node.trashedAt && !node.purgedAt);
+}
+
+function normalizeSnapshotPermissions(input, snapshot) {
+  const actorUserId = require('./identity').userId();
+  if (!actorUserId) return [];
+  const provided = Array.isArray(input?.permissions) ? input.permissions : null;
+  const values = provided || (
+    ['owner', 'editor', 'viewer'].includes(input?.role)
+      ? [{ node_id: snapshot.workspaceId, role: input.role }]
+      : []
+  );
+  const seen = new Set();
+  return values.map((value) => {
+    const nodeId = String(value?.node_id || value?.nodeId || '').toLowerCase();
+    const role = value?.role;
+    if (!snapshot.nodes.has(nodeId) || !['owner', 'editor', 'viewer', 'no_access'].includes(role)) {
+      throw invalid('workspace tree snapshot permission is invalid', 409);
+    }
+    if (seen.has(nodeId)) throw invalid('workspace tree snapshot permission is duplicated', 409);
+    seen.add(nodeId);
+    return { nodeId, userId: actorUserId, role };
+  });
+}
+
+function replaceTreeProjection(database, workspaceId, snapshot, paths, permissions, authorityEpoch) {
+  const ordered = Array.from(snapshot.nodes.values()).sort((left, right) => {
+    const leftPath = paths.get(left.id);
+    const rightPath = paths.get(right.id);
+    return (leftPath ? leftPath.split('/').length : 0) - (rightPath ? rightPath.split('/').length : 0);
+  });
+  database.transaction(() => {
+    const removedIds = database.prepare('SELECT id FROM workspace_nodes WHERE workspace_id = ?').all(workspaceId)
+      .map((row) => row.id)
+      .filter((nodeId) => !snapshot.nodes.has(nodeId));
+    if (removedIds.length) {
+      const placeholders = removedIds.map(() => '?').join(',');
+      database.prepare(`DELETE FROM doc_states WHERE node_id IN (${placeholders})`).run(...removedIds);
+      database.prepare(`DELETE FROM shared_resource_replicas WHERE resource_id IN (${placeholders})`).run(...removedIds);
+      database.prepare(`DELETE FROM shared_resource_attachments WHERE resource_id IN (${placeholders})`).run(...removedIds);
+    }
+    database.prepare('DELETE FROM workspace_node_permissions WHERE workspace_id = ?').run(workspaceId);
+    database.prepare('DELETE FROM workspace_nodes WHERE workspace_id = ?').run(workspaceId);
+    const insert = database.prepare(`
+      INSERT INTO workspace_nodes (
+        id, workspace_id, parent_id, kind, name, relative_path, symlink_target,
+        trashed_at, purged_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const node of ordered) {
+      insert.run(
+        node.id, node.workspaceId, node.parentId, node.kind, node.name,
+        paths.get(node.id), node.symlinkTarget, node.trashedAt, node.purgedAt,
+        node.createdAt, node.updatedAt,
+      );
+    }
+    const insertPermission = database.prepare(`
+      INSERT INTO workspace_node_permissions(workspace_id, node_id, user_id, role)
+      VALUES (?, ?, ?, ?)
+    `);
+    for (const permission of permissions) {
+      insertPermission.run(workspaceId, permission.nodeId, permission.userId, permission.role);
+    }
+    database.prepare(`
+      UPDATE workspace_access_state SET authority_epoch = ?, updated_at = ? WHERE workspace_id = ?
+    `).run(Number(authorityEpoch), new Date().toISOString(), workspaceId);
+  })();
+  return ordered;
+}
+
+function createProjectedNode(rootPath, node, relativePath) {
+  const target = path.join(rootPath, ...relativePath.split('/'));
+  if (node.kind === 'folder') fs.mkdirSync(target, { recursive: true });
+  else if (node.kind === 'file') {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    if (!fs.existsSync(target)) fs.writeFileSync(target, '');
+  } else if (!fs.existsSync(target) && safeSymlinkTarget(rootPath, target, node.symlinkTarget)) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.symlinkSync(node.symlinkTarget, target);
+  }
+}
+
+function materializeTreeProjection(rootPath, before, afterSnapshot, beforePaths, afterPaths) {
+  const after = afterSnapshot.nodes;
+  const removedIds = new Set();
+  for (const node of before.values()) {
+    if (node.id === node.workspaceId || !activeNode(node)) continue;
+    if (!activeNode(after.get(node.id))) removedIds.add(node.id);
+  }
+  const removedRoots = Array.from(removedIds)
+    .map((id) => before.get(id))
+    .filter((node) => !hasAncestorInSet(node, before, removedIds));
+  require('../state/docs').closeDocsByNodeIds(removedIds);
+  for (const node of removedRoots) {
+    const relative = beforePaths.get(node.id);
+    if (relative) fs.rmSync(path.join(rootPath, ...relative.split('/')), { recursive: true, force: true });
+  }
+
+  const changedIds = new Set();
+  for (const node of after.values()) {
+    if (node.id === afterSnapshot.workspaceId || !activeNode(node) || !activeNode(before.get(node.id))) continue;
+    if (beforePaths.get(node.id) !== afterPaths.get(node.id)) changedIds.add(node.id);
+  }
+  const changedRoots = Array.from(changedIds)
+    .map((id) => after.get(id))
+    .filter((node) => !hasAncestorInSet(node, after, changedIds));
+  const stagingRoot = path.join(AMALGM_DIR, 'staging', 'workspace-tree', crypto.randomBytes(12).toString('hex'));
+  const staged = [];
+  for (const node of changedRoots) {
+    const oldRelative = beforePaths.get(node.id);
+    const oldPath = path.join(rootPath, ...oldRelative.split('/'));
+    if (!fs.existsSync(oldPath)) continue;
+    const stagedPath = path.join(stagingRoot, node.id);
+    fs.mkdirSync(path.dirname(stagedPath), { recursive: true });
+    fs.renameSync(oldPath, stagedPath);
+    staged.push({ node, stagedPath });
+  }
+  for (const item of staged) {
+    const nextPath = path.join(rootPath, ...afterPaths.get(item.node.id).split('/'));
+    fs.mkdirSync(path.dirname(nextPath), { recursive: true });
+    fs.renameSync(item.stagedPath, nextPath);
+  }
+  fs.rmSync(stagingRoot, { recursive: true, force: true });
+
+  const ordered = Array.from(after.values()).sort((left, right) => {
+    const leftPath = afterPaths.get(left.id);
+    const rightPath = afterPaths.get(right.id);
+    return (leftPath ? leftPath.split('/').length : 0) - (rightPath ? rightPath.split('/').length : 0);
+  });
+  for (const node of ordered) {
+    if (node.id === afterSnapshot.workspaceId || !activeNode(node)) continue;
+    const target = path.join(rootPath, ...afterPaths.get(node.id).split('/'));
+    if (!fs.existsSync(target)) createProjectedNode(rootPath, node, afterPaths.get(node.id));
+  }
+  const changedPaths = Array.from(changedIds).map((nodeId) => ({
+    nodeId,
+    oldPath: path.join(rootPath, ...beforePaths.get(nodeId).split('/')),
+    newPath: path.join(rootPath, ...afterPaths.get(nodeId).split('/')),
+  }));
+  if (changedPaths.length) require('../state/docs').rebindNodePaths(changedPaths);
+}
+
+function enqueueProjectedContentAttachments(rootPath, snapshot, paths, input, database) {
+  const resources = Array.isArray(input?.contentResources) ? input.contentResources : [];
+  const queued = [];
+  for (const resource of resources) {
+    const nodeId = String(resource?.node_id || resource?.nodeId || '').toLowerCase();
+    const node = snapshot.nodes.get(nodeId);
+    if (!node || node.kind !== 'file' || !activeNode(node) || resource?.contract !== 'text-yjs@1') continue;
+    if (require('../state/replicas').getReplicaByResourceId(nodeId, { database })) continue;
+    if (require('../state/attachments').getAttachmentByResource(nodeId, { database })) continue;
+    const localPath = path.join(rootPath, ...paths.get(nodeId).split('/'));
+    queued.push(require('../state/attachments').enqueueAttachment({
+      attachmentId: `att_${crypto.randomBytes(16).toString('base64url')}`,
+      resourceId: nodeId,
+      localPath,
+    }, { database }).attachment);
+  }
+  return queued;
+}
+
+function enqueueWorkspaceContentAttachments(workspaceId, contentResources, options = {}) {
+  const database = options.database || openLocalDb();
+  const tree = localTree();
+  const workspace = workspaceRow(workspaceId, database);
+  if (!workspace) throw invalid('workspace tree has no local folder', 404);
+  const nodes = new Map(tree.listWorkspaceNodes(workspace.id, { database })
+    .map((node) => [node.id, node]));
+  const snapshot = { workspaceId: workspace.id, nodes };
+  return enqueueProjectedContentAttachments(
+    workspace.path,
+    snapshot,
+    pathMapForSnapshot(snapshot),
+    { contentResources },
+    database,
+  );
+}
+
+function installCloudTreeSnapshot(pathInput, input, options = {}) {
+  if (input?.contract !== 'workspace-tree@1' || Number(input?.schemaVersion) !== 1) {
+    throw invalid('unsupported workspace tree contract', 409);
+  }
+  const database = options.database || openLocalDb();
+  const { checksum, snapshot } = decodeTreeSnapshot(input);
+  if (snapshot.workspaceId !== input.resourceId) throw invalid('workspace tree identity mismatch', 409);
+  const rootPath = path.resolve(pathInput);
+  fs.mkdirSync(rootPath, { recursive: true });
+  const existingReplica = require('../state/replicas').getReplicaByResourceId(input.resourceId, { database });
+  const paths = pathMapForSnapshot(snapshot);
+  const permissions = normalizeSnapshotPermissions(input, snapshot);
+  if (existingReplica) {
+    if (existingReplica.localPath !== rootPath) throw invalid('workspace tree is bound to another folder', 409);
+    const before = new Map(
+      database.prepare('SELECT * FROM workspace_nodes WHERE workspace_id = ?').all(snapshot.workspaceId)
+        .map(rowToNode)
+        .map((node) => [node.id, node]),
+    );
+    const beforePaths = pathMapForSnapshot({ workspaceId: snapshot.workspaceId, nodes: before });
+    materializeTreeProjection(rootPath, before, snapshot, beforePaths, paths);
+    replaceTreeProjection(database, snapshot.workspaceId, snapshot, paths, permissions, input.authorityEpoch);
+    const replica = require('../state/replicas').advanceReplicaSnapshot({
+      resourceId: input.resourceId,
+      snapshotVersion: input.snapshotVersion,
+      snapshotChecksum: checksum,
+      authorityEpoch: input.authorityEpoch,
+    }, { database });
+    const contentAttachments = enqueueProjectedContentAttachments(rootPath, snapshot, paths, input, database);
+    require('../state/events').appendStateEvent({
+      resource: `${TREE_RESOURCE_PREFIX}${snapshot.workspaceId}`,
+      op: 'update', id: snapshot.workspaceId,
+      value: workspaceTreeSnapshot(snapshot.workspaceId, { database }),
+      sharedResourceId: snapshot.workspaceId,
+      source: 'workspace-tree:cloud-resnapshot',
+      resourceVersion: Number(input.snapshotVersion),
+    });
+    return { replica, contentAttachments, duplicate: false };
+  }
+  if (fs.readdirSync(rootPath).length > 0) {
+    throw invalid('cloud workspace attachment requires an empty folder', 409);
+  }
+
+  const root = snapshot.nodes.get(snapshot.workspaceId);
+  const workspace = require('./store').upsertWorkspace({
+    id: snapshot.workspaceId,
+    path: rootPath,
+    name: root.name,
+    source: 'cloud',
+  }, { source: 'workspace:cloud-attach', seedOwner: false });
+  const ordered = replaceTreeProjection(
+    database, workspace.id, snapshot, paths, permissions, input.authorityEpoch,
+  );
+  for (const node of ordered) {
+    if (node.id === workspace.id || node.trashedAt || node.purgedAt) continue;
+    createProjectedNode(rootPath, node, paths.get(node.id));
+  }
+
+  const registered = require('../state/replicas').registerReplica({
+    resourceId: input.resourceId,
+    localResource: `${TREE_RESOURCE_PREFIX}${workspace.id}`,
+    localPath: rootPath,
+    contract: input.contract,
+    schemaVersion: input.schemaVersion,
+    authorityEpoch: input.authorityEpoch,
+    appliedVersion: input.snapshotVersion,
+    snapshotVersion: input.snapshotVersion,
+    snapshotChecksum: checksum,
+  }, { database });
+  const contentAttachments = enqueueProjectedContentAttachments(rootPath, snapshot, paths, input, database);
+  require('../state/events').appendStateEvent({
+    resource: `${TREE_RESOURCE_PREFIX}${workspace.id}`,
+    op: 'update',
+    id: workspace.id,
+    value: workspaceTreeSnapshot(workspace.id, { database }),
+    sharedResourceId: workspace.id,
+    source: 'workspace-tree:cloud-snapshot',
+    resourceVersion: Number(input.snapshotVersion),
+  });
+  return { workspace, replica: registered.replica, contentAttachments, duplicate: false };
+}
+
+function applyCloudTreeMutation(input, options = {}) {
+  const envelope = input?.envelope || {};
+  if (envelope.contract !== 'workspace-tree@1') throw invalid('unsupported workspace tree mutation', 409);
+  const operation = normalizeTreeOperation(envelope.operation);
+  if (operation.workspaceId !== envelope.resourceId || operation.kind !== envelope.operationKind) {
+    throw invalid('workspace tree mutation identity mismatch', 409);
+  }
+  const database = options.database || openLocalDb();
+  const tree = localTree();
+  const workspace = workspaceRow(operation.workspaceId, database);
+  if (!workspace) throw invalid('workspace tree has no local folder', 404);
+  const before = new Map(
+    database.prepare('SELECT * FROM workspace_nodes WHERE workspace_id = ?').all(workspace.id)
+      .map(rowToNode)
+      .map((node) => [node.id, node]),
+  );
+  const after = applyTreeOperation(before, operation);
+  let paths;
+  return require('../state/mutations').ingestCloudMutation({
+    ...input,
+    localResource: `${TREE_RESOURCE_PREFIX}${workspace.id}`,
+  }, {
+    database,
+    materialize() {
+      if (operation.kind === 'tree.trash' || operation.kind === 'tree.purge') {
+        const affected = new Set(
+          Array.from(before.values())
+            .filter((node) => node.id === operation.nodeId || hasAncestorInSet(node, before, new Set([operation.nodeId])))
+            .map((node) => node.id),
+        );
+        require('../state/docs').closeDocsByNodeIds(affected);
+      }
+      paths = materializeOperation(workspace, before, after, operation);
+      paths.changedPaths = persistNodes(database, before, after, workspace.id);
+      if (paths.changedPaths.length) require('../state/docs').rebindNodePaths(paths.changedPaths);
+    },
+    event: () => ({
+      resource: `${TREE_RESOURCE_PREFIX}${workspace.id}`,
+      op: 'update',
+      id: operation.nodeId,
+      patch: operation,
+      sharedResourceId: workspace.id,
+      source: 'workspace-tree:cloud',
+      resourceVersion: Number(input.version),
+    }),
+  });
+}
+
+module.exports = {
+  applyCloudTreeMutation,
+  enqueueWorkspaceContentAttachments,
+  installCloudTreeSnapshot,
+  workspaceTreeSnapshot,
+};

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

@@ -0,0 +1,94 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const { openLocalDb } = require('../state/db');
+const { shouldSync } = require('./tree/inclusion');
+const { workspaceRow } = require('./tree/local-state');
+
+const TREE_RESOURCE_PREFIX = 'workspace-tree:';
+const MAX_TREE_SNAPSHOT_BYTES = 4 * 1024 * 1024;
+
+function invalid(message, statusCode = 400) {
+  return Object.assign(new Error(message), { statusCode });
+}
+
+function ensureWorkspaceTreePromotion(workspaceId, options = {}) {
+  if (!require('./identity').userId()) return null;
+  const database = options.database || openLocalDb();
+  const localResource = `${TREE_RESOURCE_PREFIX}${workspaceId}`;
+  const replicas = require('../state/replicas');
+  const promotions = require('../state/promotions');
+  const tree = require('./tree-store');
+  const replica = replicas.getReplicaByLocalResource(localResource, { database });
+  if (replica) return { replica, duplicate: true };
+  const existing = promotions.getPromotionByResource(workspaceId, { database });
+  if (existing) return { promotion: existing, duplicate: true };
+  const workspace = workspaceRow(workspaceId, database);
+  if (!workspace) throw invalid('workspace not found', 404);
+  const bytes = Buffer.from(JSON.stringify(tree.workspaceTreeSnapshot(workspaceId, { database })), 'utf8');
+  if (bytes.length > MAX_TREE_SNAPSHOT_BYTES) {
+    throw invalid(`workspace tree snapshot exceeds ${MAX_TREE_SNAPSHOT_BYTES} bytes`, 413);
+  }
+  return promotions.enqueuePromotion({
+    promotionId: `prm_${crypto.randomBytes(16).toString('base64url')}`,
+    resourceId: workspaceId,
+    localResource,
+    localPath: workspace.path,
+    contract: 'workspace-tree@1',
+    schemaVersion: 1,
+    snapshotBase64: bytes.toString('base64'),
+    contentBytes: bytes.length,
+    name: workspace.name,
+    mediaType: 'application/vnd.amalgm.workspace-tree+json',
+  }, { database });
+}
+
+function promoteEligibleWorkspaceTextFiles(options = {}) {
+  if (!require('./identity').userId()) return [];
+  const database = options.database || openLocalDb();
+  const tree = require('./tree-store');
+  const replicas = require('../state/replicas');
+  const promotions = require('../state/promotions');
+  const results = [];
+  for (const workspace of database.prepare('SELECT id FROM workspaces ORDER BY created_at').all()) {
+    const treeReplica = replicas.getReplicaByLocalResource(
+      `${TREE_RESOURCE_PREFIX}${workspace.id}`,
+      { database },
+    );
+    if (!treeReplica) continue;
+    for (const node of tree.listWorkspaceNodes(workspace.id, { database })) {
+      if (node.kind !== 'file' || !shouldSync(node.relativePath)) continue;
+      if (promotions.getPromotionByResource(node.id, { database })) continue;
+      if (replicas.getReplicaByResourceId(node.id, { database })) continue;
+      const filePath = tree.absolutePathForNode(node.id, { database });
+      if (!filePath) continue;
+      try {
+        const classification = require('../fs/rest')._private.classifyFile(filePath);
+        if (!classification.isText) continue;
+        const opened = require('../state/docs').openDoc(filePath);
+        results.push(promotions.enqueuePromotion({
+          promotionId: `prm_${crypto.randomBytes(16).toString('base64url')}`,
+          resourceId: node.id,
+          localResource: opened.resource,
+          localPath: opened.path,
+          contract: 'text-yjs@1',
+          schemaVersion: 1,
+          snapshotBase64: opened.state,
+          contentBytes: fs.statSync(opened.path).size,
+          name: node.name,
+          mediaType: 'application/vnd.amalgm.text-yjs-snapshot',
+        }, { database }));
+      } catch (error) {
+        console.warn(`[WorkspaceTree] text promotion skipped for ${filePath}:`, error?.message || error);
+      }
+    }
+  }
+  return results;
+}
+
+module.exports = {
+  MAX_TREE_SNAPSHOT_BYTES,
+  ensureWorkspaceTreePromotion,
+  promoteEligibleWorkspaceTextFiles,
+};