fix(filesystem): also apply FS_SEARCH_EXCLUDE_PREFIXES to directory_tree

The README documented FS_SEARCH_EXCLUDE_PREFIXES as guarding both
search_files and directory_tree, but the containment check lived only
inside searchFilesWithValidation -- so directory_tree fell back to
walking an excluded provider-backed root anyway. Docs and behaviour
disagreed; caught by @alemuenchen during his live CloudStorage test.

- Extract the check into assertSearchPathNotExcluded(rootPath, opName),
  exported from lib.ts so both call sites share the same containment
  rule (boundary-aware via isPathWithinAllowedDirectories).
- Wire it into the directory_tree handler in index.ts, before buildTree.
- Add a unit test on the shared helper for the customised opName.

Behavioural note: search_files' error wording is unchanged
("Recursive search is disabled..."); directory_tree uses the same
template with "directory_tree is disabled...".

Co-authored-by: Alessandro <alemuenchen@users.noreply.github.com>
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: 3 people

src/filesystem/__tests__/4162-timeouts-and-caps.test.ts

@@ -244,6 +244,16 @@ describe('issue #4162: timeouts + max-visited cap', () => {
       const out = await searchFilesWithValidation(sibling, '**/*', ALLOWED);
       expect(out.length).toBeGreaterThanOrEqual(0); // did not throw
     });
+
+    it('shared helper assertSearchPathNotExcluded customises the operation name', async () => {
+      // The same containment check is reused by the directory_tree handler in
+      // index.ts via assertSearchPathNotExcluded(rootPath, 'directory_tree').
+      // We can't unit-test the inline handler directly, but we can exercise
+      // the shared helper to confirm the error wording reflects the opName.
+      const { assertSearchPathNotExcluded } = await import('../lib.js');
+      expect(() => assertSearchPathNotExcluded(EXCLUDED, 'directory_tree'))
+        .toThrow(/directory_tree is disabled.*FS_SEARCH_EXCLUDE_PREFIXES/);
+    });
   });
 
   describe('env-var validation', () => {

src/filesystem/index.ts

@@ -29,6 +29,7 @@ import {
   // #4162: timeout + cap primitives reused by directory_tree
   withFsTimeout,
   FS_SEARCH_MAX_VISITED,
+  assertSearchPathNotExcluded,
 } from './lib.js';
 
 // Command line argument parsing
@@ -551,14 +552,16 @@ server.registerTool(
     }
     const rootPath = args.path;
 
-    // #4162: same defensive shape as searchFilesWithValidation -- bound the
-    // recursion and timeout each readdir so a lazy provider-backed subtree
-    // can't keep the server busy indefinitely. validatePath already wraps
-    // fs.realpath via withFsTimeout in lib.ts, so only readdir + the entry
-    // counter need handling here. We throw immediately when the cap is hit
-    // rather than threading an `aborted` flag through unwinding recursion --
-    // no caller wants a partial tree, and the immediate throw makes that
-    // contract obvious to future refactors.
+    // #4162: same defensive shape as searchFilesWithValidation -- honour
+    // FS_SEARCH_EXCLUDE_PREFIXES, bound the recursion, and timeout each
+    // readdir so a lazy provider-backed subtree can't keep the server busy
+    // indefinitely. validatePath already wraps fs.realpath via withFsTimeout
+    // in lib.ts, so only readdir + the entry counter need handling here. We
+    // throw immediately when the cap is hit rather than threading an
+    // `aborted` flag through unwinding recursion -- no caller wants a partial
+    // tree, and the immediate throw makes that contract obvious to future
+    // refactors.
+    assertSearchPathNotExcluded(rootPath, 'directory_tree');
     let visited = 0;
 
     async function buildTree(currentPath: string, excludePatterns: string[] = []): Promise<TreeEntry[]> {

src/filesystem/lib.ts

@@ -463,25 +463,30 @@ export async function headFile(filePath: string, numLines: number): Promise<stri
   }
 }
 
+// #4162: refuse recursive operations outright on user-configured slow roots.
+// Exported so both searchFilesWithValidation here and the directory_tree handler
+// in index.ts share the same containment check -- containment reuses
+// isPathWithinAllowedDirectories so it is boundary-aware: a prefix cannot match
+// an unrelated sibling that merely shares a string head.
+export function assertSearchPathNotExcluded(rootPath: string, opName: string): void {
+  if (FS_SEARCH_EXCLUDE_PREFIXES.length === 0) return;
+  const normalizedRoot = normalizePath(path.resolve(rootPath));
+  if (isPathWithinAllowedDirectories(normalizedRoot, FS_SEARCH_EXCLUDE_PREFIXES)) {
+    throw new Error(
+      `${opName} is disabled for this path by FS_SEARCH_EXCLUDE_PREFIXES: ${rootPath}. ` +
+      `Recursive operations over lazy provider-backed trees (macOS CloudStorage / FileProvider) ` +
+      `are unreliable; use list_directory on specific subfolders, or narrow the search root.`
+    );
+  }
+}
+
 export async function searchFilesWithValidation(
   rootPath: string,
   pattern: string,
   allowedDirectories: string[],
   options: SearchOptions = {}
 ): Promise<string[]> {
-  // #4162: refuse recursive search outright on user-configured slow roots.
-  // Containment reuses isPathWithinAllowedDirectories so it is boundary-aware:
-  // a prefix cannot match an unrelated sibling that merely shares a string head.
-  if (FS_SEARCH_EXCLUDE_PREFIXES.length > 0) {
-    const normalizedRoot = normalizePath(path.resolve(rootPath));
-    if (isPathWithinAllowedDirectories(normalizedRoot, FS_SEARCH_EXCLUDE_PREFIXES)) {
-      throw new Error(
-        `Recursive search is disabled for this path by FS_SEARCH_EXCLUDE_PREFIXES: ${rootPath}. ` +
-        `Recursive search over lazy provider-backed trees (macOS CloudStorage / FileProvider) ` +
-        `is unreliable; use list_directory on specific subfolders, or narrow the search root.`
-      );
-    }
-  }
+  assertSearchPathNotExcluded(rootPath, 'Recursive search');
 
   const { excludePatterns = [] } = options;
   const results: string[] = [];