Use searchFilesByName and remove searchFilesWithValidation.

Author: sebastien-rosset

src/filesystem/__tests__/lib.test.ts

@@ -16,7 +16,6 @@ import {
   readFileContent,
   writeFileContent,
   // Search & filtering functions
-  searchFilesWithValidation,
   searchFilesByName,
   // File editing functions
   applyFileEdits,
@@ -310,7 +309,7 @@ describe('Lib Functions', () => {
   });
 
   describe('Search & Filtering Functions', () => {
-    describe('searchFilesWithValidation', () => {
+    describe('searchFilesByName', () => {
       beforeEach(() => {
         mockFs.realpath.mockImplementation(async (path: any) => path.toString());
       });
@@ -327,11 +326,10 @@ describe('Lib Functions', () => {
         const testDir = process.platform === 'win32' ? 'C:\\allowed\\dir' : '/allowed/dir';
         const allowedDirs = process.platform === 'win32' ? ['C:\\allowed'] : ['/allowed'];
 
-        const result = await searchFilesWithValidation(
+        const result = await searchFilesByName(
           testDir,
           '*test*',
-          allowedDirs,
-          { excludePatterns: ['*.log', 'node_modules'] }
+          ['*.log', 'node_modules']
         );
 
         const expectedResult = process.platform === 'win32' ? 'C:\\allowed\\dir\\test.txt' : '/allowed/dir/test.txt';
@@ -357,11 +355,10 @@ describe('Lib Functions', () => {
         const testDir = process.platform === 'win32' ? 'C:\\allowed\\dir' : '/allowed/dir';
         const allowedDirs = process.platform === 'win32' ? ['C:\\allowed'] : ['/allowed'];
 
-        const result = await searchFilesWithValidation(
+        const result = await searchFilesByName(
           testDir,
           '*test*',
-          allowedDirs,
-          {}
+          []
         );
 
         // Should only return the valid file, skipping the invalid one
@@ -381,11 +378,10 @@ describe('Lib Functions', () => {
         const testDir = process.platform === 'win32' ? 'C:\\allowed\\dir' : '/allowed/dir';
         const allowedDirs = process.platform === 'win32' ? ['C:\\allowed'] : ['/allowed'];
 
-        const result = await searchFilesWithValidation(
+        const result = await searchFilesByName(
           testDir,
           '*test*',
-          allowedDirs,
-          { excludePatterns: ['*.backup'] }
+          ['*.backup']
         );
 
         const expectedResults = process.platform === 'win32' ? [

src/filesystem/index.ts

@@ -14,7 +14,6 @@ import { createReadStream } from "fs";
 import path from "path";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { minimatch } from "minimatch";
 import { normalizePath, expandHome } from './path-utils.js';
 import { getValidRootDirectories } from './roots-utils.js';
 import {
@@ -39,6 +38,7 @@ if (args.length === 0) {
   console.error("  1. Command-line arguments (shown above)");
   console.error("  2. MCP roots protocol (if client supports it)");
   console.error("At least one directory must be provided by EITHER method for the server to operate.");
+  console.error("Note: Directories will be validated at startup but operations will be retried at runtime.");
 }
 
 // Store allowed directories in normalized and resolved form
@@ -59,22 +59,33 @@ let allowedDirectories = await Promise.all(
   })
 );
 
-// Validate that all directories exist and are accessible
-await Promise.all(allowedDirectories.map(async (dir) => {
-  try {
-    const stats = await fs.stat(dir);
-    if (!stats.isDirectory()) {
-      console.error(`Error: ${dir} is not a directory`);
-      process.exit(1);
+// Validate directories at startup - log warnings if path is not accessible at startup.
+// Directory accessibility may change between startup and runtime.
+const validatedDirectories = await Promise.all(
+  allowedDirectories.map(async (dir) => {
+    try {
+      const stats = await fs.stat(dir);
+      if (stats.isDirectory()) {
+        console.error(`Directory accessible: ${dir}`);
+        return dir;
+      } else if (stats.isFile()) {
+        console.error(`${dir} is a file, not a directory - skipping`);
+        return null;
+      } else {
+        // Include symlinks/special files - they might become directories when NAS/VPN reconnects
+        console.error(`${dir} is not a directory (${stats.isSymbolicLink() ? 'symlink' : 'special file'})`);
+        return dir;
+      }
+    } catch (error) {
+      // Include inaccessible paths - they might become accessible when storage/network reconnects
+      console.error(`Directory not accessible: ${dir} - ${error instanceof Error ? error.message : String(error)}`);
+      return dir;
     }
-  } catch (error) {
-    console.error(`Error accessing directory ${dir}:`, error);
-    process.exit(1);
-  }
-}));
+  })
+).then(results => results.filter((dir): dir is string => dir !== null));
 
 // Initialize the global allowedDirectories in lib.ts
-setAllowedDirectories(allowedDirectories);
+setAllowedDirectories(validatedDirectories);
 
 // Schema definitions
 const ReadTextFileArgsSchema = z.object({
@@ -88,10 +99,7 @@ const ReadMediaFileArgsSchema = z.object({
 });
 
 const ReadMultipleFilesArgsSchema = z.object({
-  paths: z
-    .array(z.string())
-    .min(1, "At least one file path must be provided")
-    .describe("Array of file paths to read. Each path must be a string pointing to a valid file within allowed directories."),
+  paths: z.array(z.string()),
 });
 
 const WriteFileArgsSchema = z.object({
@@ -105,7 +113,7 @@ const EditOperation = z.object({
 });
 
 const EditFileArgsSchema = z.object({
-  path: z.string().describe('File path to edit'),
+  path: z.string(),
   edits: z.array(EditOperation),
   dryRun: z.boolean().default(false).describe('Preview changes using git-style diff format')
 });
@@ -125,22 +133,17 @@ const ListDirectoryWithSizesArgsSchema = z.object({
 
 const DirectoryTreeArgsSchema = z.object({
   path: z.string(),
-  excludePatterns: z.array(z.string()).optional().default([])
 });
 
 const MoveFileArgsSchema = z.object({
   source: z.string(),
   destination: z.string(),
 });
 
-const SearchFilesByNameArgsSchema = z.object({
-  path: z.string().describe('The root directory path to start the search from'),
-  pattern: z.string().describe('Pattern to match within file/directory names. Supports glob patterns. ' +
-    'Case insensitive unless pattern contains uppercase characters'),
-  excludePatterns: z.array(z.string())
-    .optional()
-    .default([])
-    .describe('Glob patterns for paths to exclude from search (e.g., "node_modules/**")')
+const SearchFilesArgsSchema = z.object({
+  path: z.string(),
+  pattern: z.string(),
+  excludePatterns: z.array(z.string()).optional().default([])
 });
 
 const GetFileInfoArgsSchema = z.object({
@@ -149,6 +152,7 @@ const GetFileInfoArgsSchema = z.object({
 
 const ToolInputSchema = ToolSchema.shape.inputSchema;
 type ToolInput = z.infer<typeof ToolInputSchema>;
+
 // Server setup
 const server = new Server(
   {
@@ -280,14 +284,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         inputSchema: zodToJsonSchema(MoveFileArgsSchema) as ToolInput,
       },
       {
-        name: "search_files_by_name",
+        name: "search_files",
         description:
-          "Recursively search for files and directories by name matching a glob pattern. " +
-          "Supports glob-style patterns that match paths relative to the working directory. " +
-          "Use patterns like '*.ext' to match files in current directory, and '**/*.ext' to match files in all subdirectories. " +
-          "Returns full paths to all matching items. Great for finding files when you don't know their exact location. " +
+          "Recursively search for files and directories matching a pattern. " +
+          "Searches through all subdirectories from the starting path. The search " +
+          "is case-insensitive and matches partial names. Returns full paths to all " +
+          "matching items. Great for finding files when you don't know their exact location. " +
           "Only searches within allowed directories.",
-        inputSchema: zodToJsonSchema(SearchFilesByNameArgsSchema) as ToolInput,
+        inputSchema: zodToJsonSchema(SearchFilesArgsSchema) as ToolInput,
       },
       {
         name: "get_file_info",
@@ -536,36 +540,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             type: 'file' | 'directory';
             children?: TreeEntry[];
         }
-        const rootPath = parsed.data.path;
 
-        async function buildTree(currentPath: string, excludePatterns: string[] = []): Promise<TreeEntry[]> {
+        async function buildTree(currentPath: string): Promise<TreeEntry[]> {
             const validPath = await validatePath(currentPath);
             const entries = await fs.readdir(validPath, {withFileTypes: true});
             const result: TreeEntry[] = [];
 
             for (const entry of entries) {
-                const relativePath = path.relative(rootPath, path.join(currentPath, entry.name));
-                const shouldExclude = excludePatterns.some(pattern => {
-                    if (pattern.includes('*')) {
-                        return minimatch(relativePath, pattern, {dot: true});
-                    }
-                    // For files: match exact name or as part of path
-                    // For directories: match as directory path
-                    return minimatch(relativePath, pattern, {dot: true}) ||
-                           minimatch(relativePath, `**/${pattern}`, {dot: true}) ||
-                           minimatch(relativePath, `**/${pattern}/**`, {dot: true});
-                });
-                if (shouldExclude)
-                    continue;
-
                 const entryData: TreeEntry = {
                     name: entry.name,
                     type: entry.isDirectory() ? 'directory' : 'file'
                 };
 
                 if (entry.isDirectory()) {
                     const subPath = path.join(currentPath, entry.name);
-                    entryData.children = await buildTree(subPath, excludePatterns);
+                    entryData.children = await buildTree(subPath);
                 }
 
                 result.push(entryData);
@@ -574,7 +563,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             return result;
         }
 
-        const treeData = await buildTree(rootPath, parsed.data.excludePatterns);
+        const treeData = await buildTree(parsed.data.path);
         return {
             content: [{
                 type: "text",
@@ -596,10 +585,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
-      case "search_files_by_name": {
-        const parsed = SearchFilesByNameArgsSchema.safeParse(args);
+      case "search_files": {
+        const parsed = SearchFilesArgsSchema.safeParse(args);
         if (!parsed.success) {
-          throw new Error(`Invalid arguments for search_files_by_name: ${parsed.error}`);
+          throw new Error(`Invalid arguments for search_files: ${parsed.error}`);
         }
         const validPath = await validatePath(parsed.data.path);
         const results = await searchFilesByName(validPath, parsed.data.pattern, parsed.data.excludePatterns);
@@ -616,11 +605,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const validPath = await validatePath(parsed.data.path);
         const info = await getFileStats(validPath);
         return {
-          content: [{
-            type: "text", text: Object.entries(info)
-              .map(([key, value]) => `${key}: ${value}`)
-              .join("\n")
-          }],
+          content: [{ type: "text", text: Object.entries(info)
+            .map(([key, value]) => `${key}: ${value}`)
+            .join("\n") }],
         };
       }
 

src/filesystem/lib.ts

@@ -455,14 +455,3 @@ export async function searchFilesByName(
 
   return results;
 }
-
-// Legacy function for backward compatibility
-export async function searchFilesWithValidation(
-  rootPath: string,
-  pattern: string,
-  allowedDirectories: string[],
-  options: SearchOptions = {}
-): Promise<string[]> {
-  const { excludePatterns = [] } = options;
-  return searchFilesByName(rootPath, pattern, excludePatterns);
-}