amalgm 0.1.165 → 0.1.166

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.165",
+  "version": "0.1.166",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

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

@@ -72,6 +72,26 @@ test('enrollment gives every node a UUID and open docs keep one resource through
   assert.equal(state.node_id, beforeNode.id);
 });
 
+test('bounded automatic tree passes skip large workspaces without blocking explicit enrollment', () => {
+  const root = path.join(process.env.AMALGM_WORKSPACES_DIR, 'bounded-observer');
+  fs.mkdirSync(root, { recursive: true });
+  fs.writeFileSync(path.join(root, 'one.txt'), 'one\n');
+  fs.writeFileSync(path.join(root, 'two.txt'), 'two\n');
+  const workspace = upsertWorkspace({ path: root, name: 'Bounded observer', source: 'computer' });
+
+  const boundedEnrollment = enrollWorkspace(workspace.id, { maxNodes: 1 });
+  assert.equal(boundedEnrollment.skipped, 'node_limit');
+  assert.equal(listWorkspaceNodes(workspace.id).length, 1, 'bounded scan must not persist a partial tree');
+
+  const explicitEnrollment = enrollWorkspace(workspace.id);
+  assert.equal(explicitEnrollment.nodes.length, 3, 'explicit enrollment remains available for intentional work');
+
+  fs.writeFileSync(path.join(root, 'three.txt'), 'three\n');
+  const boundedReconcile = reconcileWorkspaceTree(workspace.id, { maxNodes: 1 });
+  assert.equal(boundedReconcile.skipped, 'node_limit');
+  assert.equal(nodeForPath(path.join(root, 'three.txt')), null, 'automatic reconciliation skips the oversized tree');
+});
+
 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');

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

@@ -19,6 +19,11 @@ const { normalizeTreeOperation } = require('./tree/operations');
 const { uuidV7 } = require('./tree/identity');
 
 const TREE_RESOURCE_PREFIX = 'workspace-tree:';
+// Tree enrollment and disk observation run inside the MCP process. Keep those
+// automatic passes bounded so one very large workspace cannot monopolize the
+// event loop and make the runtime health endpoint unavailable. Explicit
+// workspace operations remain uncapped.
+const AUTOMATIC_TREE_NODE_LIMIT = 2_000;
 
 function invalid(message, statusCode = 400) {
   return Object.assign(new Error(message), { statusCode });
@@ -84,7 +89,29 @@ function statIdentity(stats) {
   return { deviceId: String(stats.dev), inode: String(stats.ino) };
 }
 
-function scanDirectory(rootPath) {
+function treeNodeLimit(options = {}) {
+  if (options.maxNodes == null) return null;
+  const value = Number(options.maxNodes);
+  return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+
+function treeNodeLimitError(limit) {
+  return Object.assign(new Error(`workspace tree exceeds automatic limit of ${limit} nodes`), {
+    code: 'WORKSPACE_TREE_NODE_LIMIT',
+  });
+}
+
+function skippedTreeResult(workspaceId, limit, nodeCount = null) {
+  return {
+    workspaceId,
+    skipped: 'node_limit',
+    maxNodes: limit,
+    ...(nodeCount == null ? {} : { nodeCount }),
+  };
+}
+
+function scanDirectory(rootPath, options = {}) {
+  const maxNodes = treeNodeLimit(options);
   const entries = [];
   const visit = (directory, parentRelativePath) => {
     const children = fs.readdirSync(directory, { withFileTypes: true })
@@ -95,6 +122,7 @@ function scanDirectory(rootPath) {
       const absolutePath = path.join(directory, child.name);
       const stats = fs.lstatSync(absolutePath);
       const kind = stats.isSymbolicLink() ? 'symlink' : stats.isDirectory() ? 'folder' : 'file';
+      if (maxNodes != null && entries.length >= maxNodes) throw treeNodeLimitError(maxNodes);
       entries.push({
         relativePath,
         parentRelativePath,
@@ -124,7 +152,23 @@ function enrollWorkspace(identifier, options = {}) {
   const rootStats = fs.statSync(rootPath);
   if (!rootStats.isDirectory()) throw invalid('workspace path is not a folder', 409);
 
-  const scanned = scanDirectory(rootPath);
+  const maxNodes = treeNodeLimit(options);
+  const existingNodeCount = database.prepare(
+    'SELECT count(*) AS count FROM workspace_nodes WHERE workspace_id = ?',
+  ).get(workspace.id).count;
+  if (maxNodes != null && existingNodeCount > maxNodes) {
+    return skippedTreeResult(workspace.id, maxNodes, existingNodeCount);
+  }
+
+  let scanned;
+  try {
+    scanned = scanDirectory(rootPath, { maxNodes });
+  } catch (error) {
+    if (error?.code === 'WORKSPACE_TREE_NODE_LIMIT') {
+      return skippedTreeResult(workspace.id, maxNodes, existingNodeCount);
+    }
+    throw error;
+  }
   const existing = database.prepare('SELECT * FROM workspace_nodes WHERE workspace_id = ?').all(workspace.id);
   const byPath = new Map(existing.map((row) => [row.relative_path, row]));
   const byIdentity = new Map();
@@ -487,8 +531,8 @@ function enrollRegisteredWorkspaces(options = {}) {
   const results = [];
   for (const workspace of workspaces) {
     try {
-      const result = enrollWorkspace(workspace.id, { database });
-      ensureWorkspaceTreePromotion(workspace.id, { database });
+      const result = enrollWorkspace(workspace.id, { database, maxNodes: options.maxNodes });
+      if (!result.skipped) ensureWorkspaceTreePromotion(workspace.id, { database });
       results.push(result);
     } catch (error) {
       console.warn(`[WorkspaceTree] enrollment failed for ${workspace.id}:`, error?.message || error);
@@ -506,6 +550,13 @@ function reconcileWorkspaceTree(identifier, options = {}) {
   const database = options.database || openLocalDb();
   const workspace = workspaceRow(identifier, database);
   if (!workspace || !fs.existsSync(workspace.path)) return { operations: [] };
+  const maxNodes = treeNodeLimit(options);
+  const existingNodeCount = database.prepare(
+    'SELECT count(*) AS count FROM workspace_nodes WHERE workspace_id = ?',
+  ).get(workspace.id).count;
+  if (maxNodes != null && existingNodeCount > maxNodes) {
+    return skippedTreeResult(workspace.id, maxNodes, existingNodeCount);
+  }
   const operations = [];
   const held = [];
   const heldNodeIds = new Set();
@@ -524,7 +575,15 @@ function reconcileWorkspaceTree(identifier, options = {}) {
     }
   };
 
-  const scanned = scanDirectory(workspace.path);
+  let scanned;
+  try {
+    scanned = scanDirectory(workspace.path, { maxNodes });
+  } catch (error) {
+    if (error?.code === 'WORKSPACE_TREE_NODE_LIMIT') {
+      return skippedTreeResult(workspace.id, maxNodes, existingNodeCount);
+    }
+    throw error;
+  }
   let rows = listWorkspaceNodes(workspace.id, {
     database,
     includeTrashed: true,
@@ -605,7 +664,7 @@ function reconcileRegisteredWorkspaceTrees(options = {}) {
   const results = [];
   for (const workspace of database.prepare('SELECT id FROM workspaces ORDER BY created_at').all()) {
     try {
-      results.push(reconcileWorkspaceTree(workspace.id, { database }));
+      results.push(reconcileWorkspaceTree(workspace.id, { database, maxNodes: options.maxNodes }));
     } catch (error) {
       console.warn(`[WorkspaceTree] observation failed for ${workspace.id}:`, error?.message || error);
     }
@@ -617,9 +676,15 @@ let enrollmentStarted = false;
 function startTreeEnrollmentService() {
   if (enrollmentStarted) return;
   enrollmentStarted = true;
-  const timer = setTimeout(() => enrollRegisteredWorkspaces(), 0);
+  const timer = setTimeout(
+    () => enrollRegisteredWorkspaces({ maxNodes: AUTOMATIC_TREE_NODE_LIMIT }),
+    0,
+  );
   if (typeof timer.unref === 'function') timer.unref();
-  const observationTimer = setInterval(() => reconcileRegisteredWorkspaceTrees(), 2_000);
+  const observationTimer = setInterval(
+    () => reconcileRegisteredWorkspaceTrees({ maxNodes: AUTOMATIC_TREE_NODE_LIMIT }),
+    2_000,
+  );
   if (typeof observationTimer.unref === 'function') observationTimer.unref();
   const promotionTimer = setInterval(() => {
     try {