mcp-fs-shell-windows 0.2.6 → 0.2.18

package/dist/search_regex/handler.js

@@ -1,14 +1,15 @@
 import fs from "fs/promises";
 import path from "path";
-import { validatePath } from "../helpers/path.js";
+import { validatePath, stripLongPath } from "../helpers/path.js";
 import { minimatch } from "minimatch";
-export async function handleSearchRegex(searchPath, pattern, filePatterns, excludePatterns, maxResults, caseSensitive, offset, allowedDirectories) {
+export async function handleSearchRegex(searchPath, pattern, filePatterns, excludePatterns, maxResults, caseSensitive, offset, allowedDirectories, countOnly) {
     // Validate root path (may be a directory or a single file)
     const validRootPath = await validatePath(searchPath, allowedDirectories);
     const results = [];
+    const perFileCounts = new Map();
+    const filesSearchedList = [];
     let filesSearched = 0;
-    let matchesFound = 0;
-    let searchAborted = false;
+    let totalMatches = 0;
     const effectiveCap = offset - 1 + maxResults;
     // Create regex pattern
     const regexFlags = caseSensitive ? "mg" : "img";
@@ -20,38 +21,40 @@ export async function handleSearchRegex(searchPath, pattern, filePatterns, exclu
         throw new Error(`Invalid regular expression: ${pattern}`);
     }
     async function scanFile(fullPath) {
-        if (searchAborted)
-            return;
         try {
             filesSearched++;
+            filesSearchedList.push(fullPath);
             const content = await fs.readFile(fullPath, "utf-8");
             const lines = content.split("\n");
             regex.lastIndex = 0;
             let match;
+            // Every occurrence is counted (a line containing the pattern 4 times
+            // counts as 4 matches). Line results are collected only while under the
+            // pagination cap; counting always runs to completion so the reported
+            // total is exact.
             while ((match = regex.exec(content)) !== null) {
-                matchesFound++;
-                // Find the line number for this match
-                const matchPosition = match.index;
-                let lineNumber = 0;
-                let charCount = 0;
-                for (let i = 0; i < lines.length; i++) {
-                    charCount += lines[i].length + 1; // +1 for the newline
-                    if (charCount > matchPosition) {
-                        lineNumber = i + 1;
-                        break;
+                totalMatches++;
+                perFileCounts.set(fullPath, (perFileCounts.get(fullPath) ?? 0) + 1);
+                if (!countOnly && results.length < effectiveCap) {
+                    // Find the line number for this match
+                    const matchPosition = match.index;
+                    let lineNumber = 0;
+                    let charCount = 0;
+                    for (let i = 0; i < lines.length; i++) {
+                        charCount += lines[i].length + 1; // +1 for the newline
+                        if (charCount > matchPosition) {
+                            lineNumber = i + 1;
+                            break;
+                        }
                     }
-                }
-                // Get the line content
-                const lineContent = lines[lineNumber - 1]?.trim() || "";
-                results.push({
-                    file: fullPath,
-                    line: lineNumber,
-                    content: lineContent,
-                    match: match[0],
-                });
-                if (results.length >= effectiveCap) {
-                    searchAborted = true;
-                    break;
+                    // Get the line content
+                    const lineContent = lines[lineNumber - 1]?.trim() || "";
+                    results.push({
+                        file: fullPath,
+                        line: lineNumber,
+                        content: lineContent,
+                        match: match[0],
+                    });
                 }
                 // Guard against zero-length matches (e.g. pattern "a*") looping forever
                 if (match[0].length === 0) {
@@ -64,13 +67,9 @@ export async function handleSearchRegex(searchPath, pattern, filePatterns, exclu
         }
     }
     async function searchDirectory(dirPath) {
-        if (searchAborted)
-            return;
         try {
             const entries = await fs.readdir(dirPath, { withFileTypes: true });
             for (const entry of entries) {
-                if (searchAborted)
-                    break;
                 const fullPath = path.join(dirPath, entry.name);
                 try {
                     // Validate each path before processing
@@ -122,22 +121,44 @@ export async function handleSearchRegex(searchPath, pattern, filePatterns, exclu
     else {
         await searchDirectory(validRootPath);
     }
+    // Total-match summary (always included), with per-file counts for the
+    // files that contain at least one match, in first-match (walk) order.
+    const matchedFileEntries = [...perFileCounts.entries()];
+    const matchedFilesCount = matchedFileEntries.length;
+    let matchedFilesList = "";
+    for (const [file, count] of matchedFileEntries) {
+        matchedFilesList += `  ${stripLongPath(file)}: ${count}\n`;
+    }
+    const totalLine = `Total matches: ${totalMatches} (${matchedFilesCount} files)\n`;
     // Format the results
     let output = "";
-    const shown = results.slice(offset - 1);
-    if (matchesFound === 0) {
+    const shown = countOnly ? [] : results.slice(offset - 1);
+    if (countOnly) {
+        // Counts only: total header, files searched, then a per-file count line
+        // for EVERY searched file (0 for files with no matches).
+        output = totalLine;
+        output += `Searched ${filesSearched} files\n`;
+        if (totalMatches > 0) {
+            output += "\n";
+            for (const file of filesSearchedList) {
+                output += `  ${stripLongPath(file)}: ${perFileCounts.get(file) ?? 0}\n`;
+            }
+        }
+    }
+    else if (totalMatches === 0) {
         output = `No matches found for regex: ${pattern}\n`;
         output += `Searched ${filesSearched} files\n`;
+        output += totalLine;
     }
     else if (shown.length === 0) {
-        output = `Found ${matchesFound} matches in ${results.length} locations (offset ${offset} is beyond the collected range)\n`;
+        output = `Found ${totalMatches} matches in ${results.length} locations (offset ${offset} is beyond the collected range)\n`;
+        output += "\n";
+        output += totalLine;
+        output += matchedFilesList;
     }
     else {
         const end = offset + shown.length - 1;
-        output = `Found ${matchesFound} matches in ${results.length} locations (showing ${offset}-${end})`;
-        if (searchAborted) {
-            output += ` (search stopped at ${effectiveCap} collected matches)`;
-        }
+        output = `Found ${totalMatches} matches in ${results.length} locations (showing ${offset}-${end})`;
         output += "\n\n";
         // Group by file for more readable output
         const fileGroups = new Map();
@@ -148,12 +169,14 @@ export async function handleSearchRegex(searchPath, pattern, filePatterns, exclu
             fileGroups.get(result.file)?.push(result);
         }
         for (const [file, fileResults] of fileGroups.entries()) {
-            output += `File: ${file}\n`;
+            output += `File: ${stripLongPath(file)}\n`;
             for (const result of fileResults) {
                 output += `  Line ${result.line}: ${result.content}\n`;
             }
             output += "\n";
         }
+        output += totalLine;
+        output += matchedFilesList;
     }
     return output;
 }

package/dist/search_regex/schema.js

@@ -7,4 +7,5 @@ export const SearchRegexArgsSchema = z.object({
     maxResults: z.number().optional().default(100).describe("Maximum number of results to return"),
     offset: z.number().int().min(1).optional().default(1).describe("1-indexed match number to start from. Default: 1."),
     caseSensitive: z.boolean().optional().default(false).describe("Whether the search should be case-sensitive"),
+    countOnly: z.boolean().optional().default(false).describe("When true, return only per-file match counts and the total (no matching line text). Default: false."),
 });

package/dist/server.js

@@ -2,6 +2,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ToolSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { stripLongPathAll } from "./helpers/path.js";
 // Import all schemas
 import { ReadFilesArgsSchema } from "./read_files/schema.js";
 import { WriteNewFilesArgsSchema } from "./write_new_files/schema.js";
@@ -17,6 +18,7 @@ import { ListDirectoryArgsSchema } from "./list_directory/schema.js";
 import { DirectoryTreeArgsSchema } from "./directory_tree/schema.js";
 import { SearchFilesArgsSchema } from "./search_files/schema.js";
 import { SearchRegexArgsSchema } from "./search_regex/schema.js";
+import { ReplaceRegexArgsSchema } from "./replace_regex/schema.js";
 import { SearchGlobArgsSchema } from "./search_glob/schema.js";
 import { CountLinesArgsSchema } from "./count_lines/schema.js";
 import { ChecksumFilesArgsSchema } from "./checksum_files/schema.js";
@@ -25,6 +27,13 @@ import { GetFileInfoArgsSchema } from "./file_info/schema.js";
 import { EditFilesArgsSchema } from "./edit_files/schema.js";
 import { FuzzyFindFilesArgsSchema } from "./fuzzy_find_files/schema.js";
 import { DeleteFilesByPatternArgsSchema } from "./delete_files_by_pattern/schema.js";
+import { LaunchFileArgsSchema } from "./launch_file/schema.js";
+import { ReadBytesArgsSchema } from "./read_bytes/schema.js";
+import { WriteBytesArgsSchema } from "./write_bytes/schema.js";
+import { DirDiffArgsSchema } from "./dir_diff/schema.js";
+import { ConvertEncodingArgsSchema } from "./convert_encoding/schema.js";
+import { WaitForFileArgsSchema } from "./wait_for_file/schema.js";
+import { CreateLinkArgsSchema } from "./create_link/schema.js";
 import { ShellRunArgsSchema } from "./shell/schema.js";
 import { ShellTestArgsSchema } from "./shell/schema.js";
 import { ShellStartArgsSchema } from "./shell/schema.js";
@@ -48,6 +57,7 @@ import { handleListDirectory } from "./list_directory/handler.js";
 import { handleDirectoryTree } from "./directory_tree/handler.js";
 import { handleSearchFiles } from "./search_files/handler.js";
 import { handleSearchRegex } from "./search_regex/handler.js";
+import { handleReplaceRegex } from "./replace_regex/handler.js";
 import { handleSearchGlob } from "./search_glob/handler.js";
 import { handleCountLines } from "./count_lines/handler.js";
 import { handleChecksumFiles } from "./checksum_files/handler.js";
@@ -56,6 +66,13 @@ import { handleGetFileInfo } from "./file_info/handler.js";
 import { handleEditFiles } from "./edit_files/handler.js";
 import { handleFuzzyFindFiles } from "./fuzzy_find_files/handler.js";
 import { handleDeleteFilesByPattern } from "./delete_files_by_pattern/handler.js";
+import { handleLaunchFile } from "./launch_file/handler.js";
+import { handleReadBytes } from "./read_bytes/handler.js";
+import { handleWriteBytes } from "./write_bytes/handler.js";
+import { handleDirDiff } from "./dir_diff/handler.js";
+import { handleConvertEncoding } from "./convert_encoding/handler.js";
+import { handleWaitForFile } from "./wait_for_file/handler.js";
+import { handleCreateLink } from "./create_link/handler.js";
 import { handleShellRun } from "./shell/handler.js";
 import { handleShellTest } from "./shell/handler.js";
 import { handleShellStart } from "./shell/handler.js";
@@ -72,7 +89,7 @@ export class FilesystemServer {
         this.allowedDirectories = allowedDirectories;
         this.server = new Server({
             name: "secure-filesystem-server",
-            version: "0.2.4",
+            version: "0.2.18",
         }, {
             capabilities: {
                 tools: {},
@@ -91,6 +108,8 @@ export class FilesystemServer {
                             "Each line is prefixed with its line number (format: \"1: line content\"). " +
                             "Each file's content is returned with its path as a reference. " +
                             "Use offset (1-indexed start line) and/or limit (max lines) to read a range of a large file. " +
+                            "Each paths item may be a plain string or an object {path, encoding?, offset?, limit?}. " +
+                            "encoding decodes the file as 'utf8' | 'utf16le' | 'utf16be' | 'cp1252' (a matching BOM is stripped); without encoding the file's encoding is auto-detected (BOM FF FE -> utf16le, FE FF -> utf16be, EF BB BF -> utf8, otherwise strict UTF-8 -> utf8, else cp1252). " +
                             "Only works within allowed directories.",
                         inputSchema: zodToJsonSchema(ReadFilesArgsSchema),
                     },
@@ -98,7 +117,7 @@ export class FilesystemServer {
                         name: "write_new_files",
                         description: "Create multiple new files in a single operation. Works on a single file too. " +
                             "Fails if a file already exists unless its overwrite flag is true. " +
-                            "Handles text content with UTF-8 encoding, or base64 content for binary files (encoding: \"base64\"). " +
+                            "Handles text content with UTF-8 encoding (or a per-file textEncoding of 'utf8' | 'utf16le' | 'utf16be' | 'cp1252'; utf16le/utf16be write a BOM), or base64 content for binary files (encoding: \"base64\", which writes raw bytes and wins over textEncoding). " +
                             "Parent directories are created as needed. " +
                             "Partial failures won't stop the entire operation. " +
                             "Only works within allowed directories.",
@@ -117,8 +136,10 @@ export class FilesystemServer {
                         name: "delete_files",
                         description: "Delete multiple files or directories in a single operation. Works on a single file too. " +
                             "Set recursive flag to true to delete directories with contents. " +
+                            "Reparse points (junctions/symlinks) are always removed as links without following them - the link target is never touched, including nested links inside recursively deleted directories. " +
+                            "Set toRecycleBin to true (Windows only) to send files and directories to the Recycle Bin instead of deleting permanently; reparse points are still removed as links (the bin cannot hold links), and any path that cannot be recycled is reported as an error and never permanently deleted as a fallback. " +
                             "Partial failures won't stop the entire operation. " +
-                            "Use with caution as operation is permanent. " +
+                            "Use with caution as the default operation is permanent. " +
                             "Only works within allowed directories.",
                         inputSchema: zodToJsonSchema(DeleteFilesArgsSchema),
                     },
@@ -151,7 +172,7 @@ export class FilesystemServer {
                             "Each patch has an action: replace (default, replace lines startLine-endLine with newText), insertBefore (insert newText before startLine; startLine = total lines + 1 appends to the end), or delete (remove lines startLine-endLine). " +
                             "All patches reference the original line numbers. " +
                             "Shows git-style diffs for all changes (dryRun: true previews without writing). " +
-                            "Note: files are written back with LF line endings. " +
+                            "Preserves the file's dominant line ending (CRLF or LF). " +
                             "Partial failures won't stop the entire operation. " +
                             "Only works within allowed directories.",
                         inputSchema: zodToJsonSchema(PatchFilesArgsSchema),
@@ -167,10 +188,11 @@ export class FilesystemServer {
                     },
                     {
                         name: "list_directory",
-                        description: "List directory contents with [FILE] or [DIR] prefixes (single level). " +
+                        description: "List directory contents with [FILE], [DIR], or [LINK] prefixes (single level). " +
                             "Entries are sorted by name and paginated with offset/limit (default limit 100). " +
                             "File sizes are shown by default (includeSizes: false to omit). " +
                             "Filter with type (files/directories/all) and ignore glob patterns. " +
+                            "Reparse points (junctions/symlinks) show as [LINK] and are excluded from the files and directories filters (only listed with type 'all'); links are not stat'ed for size. " +
                             "Use directory_tree for recursive views. " +
                             "Only works within allowed directories.",
                         inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
@@ -180,6 +202,8 @@ export class FilesystemServer {
                         description: "Get a recursive tree view of files and directories as a JSON structure. " +
                             "Returns JSON with name, type, and children properties. " +
                             "Supports excluding files/directories using glob patterns. " +
+                            "Reparse points (junctions/symlinks) appear as type 'link' with no children and are never recursed into. " +
+                            "Empty directories are included. " +
                             "Only works within allowed directories.",
                         inputSchema: zodToJsonSchema(DirectoryTreeArgsSchema),
                     },
@@ -198,9 +222,23 @@ export class FilesystemServer {
                             "path can be a directory (recursively searched) or a single file. " +
                             "Supports filtering files by patterns. " +
                             "Returns matching lines with line numbers, paginated with offset/maxResults (default 100). " +
+                            "Each occurrence of the pattern is counted (a line matching 4 times counts as 4), and the response " +
+                            "always ends with the total match count plus per-file counts. " +
+                            "Set countOnly=true to return only per-file match counts and the total, with no matching line text. " +
                             "Only searches within allowed directories.",
                         inputSchema: zodToJsonSchema(SearchRegexArgsSchema),
                     },
+                    {
+                        name: "replace_regex",
+                        description: "In-place regular expression replacement across the given FILES. " +
+                            "paths may list one or many files (directories are NOT accepted - a directory path is an error and nothing is written). " +
+                            "The 'g' (global) flag is always applied so every match is replaced; additional flags such as 'i' are allowed. " +
+                            "dryRun defaults to TRUE: it returns per-file match counts and a unified diff preview of the WOULD-BE change without writing anything. " +
+                            "With dryRun=false the replacements are applied in place, preserving each file's dominant line ending (a pure-CRLF file stays fully CRLF), and per-file match counts plus a total are returned. " +
+                            "Any missing path or an invalid regex produces a clear error and writes nothing. " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(ReplaceRegexArgsSchema),
+                    },
                     {
                         name: "search_glob",
                         description: "Find files using glob patterns. " +
@@ -238,7 +276,7 @@ export class FilesystemServer {
                     {
                         name: "get_file_info",
                         description: "Get detailed file/directory metadata. " +
-                            "Returns size, creation time, modified time, access time, type, and permissions. " +
+                            "Returns size, creation time, modified time, access time, type, permissions, isReparsePoint, and (on Windows) NTFS attributes. " +
                             "Only works within allowed directories.",
                         inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
                     },
@@ -279,6 +317,19 @@ export class FilesystemServer {
                             "Only works within allowed directories.",
                         inputSchema: zodToJsonSchema(DeleteFilesByPatternArgsSchema),
                     },
+                    {
+                        name: "create_link",
+                        description: "Create a link object at linkPath pointing at target (Windows hardlink, directory junction, or file/directory symlink). " +
+                            "type: 'auto' (default) | 'symlink' | 'junction' | 'hardlink'. " +
+                            "target must exist (lstat-checked; clear error otherwise); linkPath must NOT already exist (clear error); linkPath's parent directory must already exist (clear error - it is NOT auto-created). " +
+                            "'hardlink' creates a second name for an existing file (target must be a file; same volume - cross-volume errors surface naturally). " +
+                            "'junction' creates a directory junction (Windows only; target must be a directory; clear error on non-Windows). " +
+                            "'symlink'/'auto' create a real symlink based on the target's type: directory target -> directory symlink, file target -> file symlink; 'auto' never creates a junction (junctions must be explicit). " +
+                            "Both paths go through the standard path validation and must be within allowed directories. " +
+                            "Response is short text containing the user-supplied linkPath and target (never any \\\\?\\-prefixed form) plus the actual link type created. " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(CreateLinkArgsSchema),
+                    },
                     {
                         name: "transfer_files",
                         description: "Move or rename multiple files and directories in a single operation. Works on a single file too. " +
@@ -354,6 +405,68 @@ export class FilesystemServer {
                             "The default starts as the MCP server process's CWD and resets when the server restarts.",
                         inputSchema: zodToJsonSchema(ShellCwdArgsSchema),
                     },
+                    {
+                        name: "launch_file",
+                        description: "Launch a file, folder, or web link in its Windows-associated application (the OS default: e.g. VLC for .mkv/.mp4, Explorer for folders, the default browser for http(s) URLs). " +
+                            "File/folder paths must be within the allowed directories (C:/, D:/, M:, NAS UNC) and are checked for existence; only http:// and https:// links are launched - file: URLs and other protocol schemes (javascript:, ms-*, steam:, vlc:) are rejected. " +
+                            "The launch is fully detached: it returns once Windows has spawned the shell opener - it never waits for the opened application, does not inherit the server's stdio pipes, creates no intermediary console window, and passes file names verbatim (spaces, Unicode, apostrophes, ampersands, parentheses all safe). " +
+                            "Errors if the path does not exist, is outside the allowed directories, the URL scheme is not http/https, or the opener fails to spawn.",
+                        inputSchema: zodToJsonSchema(LaunchFileArgsSchema),
+                    },
+                    {
+                        name: "read_bytes",
+                        description: "Read raw bytes from a file at a given (offset, length). " +
+                            "All arguments are integers: offset >= 0, length >= 1. " +
+                            "An offset at or beyond the file's end (offset >= size) is an error ('offset beyond EOF'); if offset+length exceeds the file size, the read is clamped to EOF. " +
+                            "Returns JSON text: {path, offset, length, actualLength, size, dataBase64} where dataBase64 is base64 of the bytes actually read. " +
+                            "Works on binary files of any size (e.g. GGUFs, blobs). " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(ReadBytesArgsSchema),
+                    },
+                    {
+                        name: "write_bytes",
+                        description: "Write raw bytes to an existing file at a given offset (base64 input). " +
+                            "The file must already exist (no implicit create); invalid base64 is an error. " +
+                            "With the default extend=false, offset+bytes.length must not exceed the file size (else an error) and the bytes overwrite in place. " +
+                            "With extend=true the file is grown when the write ends past EOF, zero-filling any gap between the old size and the offset. " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(WriteBytesArgsSchema),
+                    },
+                    {
+                        name: "dir_diff",
+                        description: "Recursively compare the contents of two directory trees (files only). " +
+                            "Each relative path is classified as added (exists only in dirB), removed (exists only in dirA), " +
+                            "changed (present in both, content differs - decided by size first, then sha256), or identical. " +
+                            "For changed files where BOTH sides look like text (size <= 1 MiB and no NUL byte in the first 8 KiB), " +
+                            "a unified diff is included (diff? field, same helper as file_diff/content_diff). " +
+                            "ignore: array of glob patterns matched against each file's relative path (minimatch, same semantics as list_directory's ignore param); ignored paths are excluded from all lists and counts. " +
+                            "maxFiles: cap on total files compared (union of both trees); if the union exceeds it, the comparison stops and truncated=true (counts reflect what was compared). " +
+                            "Returns JSON text: {added:[{path,size}], removed:[{path,size}], changed:[{path,sizeA,sizeB,shaA,shaB,diff?}], counts:{added,removed,changed,identical,compared}, truncated}. " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(DirDiffArgsSchema),
+                    },
+                    {
+                        name: "convert_encoding",
+                        description: "Convert a file's text encoding to a new file. " +
+                            "Reads the source file (encoding auto-detected from its bytes unless `from` is given: BOM FF FE -> utf16le, FE FF -> utf16be, EF BB BF -> utf8, otherwise strict UTF-8 -> utf8, else cp1252), decodes it, and writes outPath encoded as `to` ('utf8' | 'utf16le' | 'utf16be' | 'cp1252'; utf16le/utf16be output includes a BOM, utf8/cp1252 do not). " +
+                            "outPath must differ from path and must not already exist unless overwrite=true. " +
+                            "Returns JSON text: {path, outPath, from (detected or given), to, bytesIn, bytesOut}. " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(ConvertEncodingArgsSchema),
+                    },
+                    {
+                        name: "wait_for_file",
+                        description: "Wait until at least one file matching a glob appears under a base directory (polling watcher). " +
+                            "path = base directory (must be inside an allowed root); the glob is matched against each file's path relative to path " +
+                            "(same glob machinery as search_glob: minimatch with dot:true; on Windows backslashes in the pattern are treated as path separators). " +
+                            "timeoutMs defaults to 30000 (max 300000); intervalMs defaults to 500 (min 100). " +
+                            "Polls with an async sleep between scans so the server thread is never blocked for longer than one interval; the tool call itself may legitimately take up to timeoutMs. " +
+                            "As soon as at least one file matches it returns JSON text: {matched: [absolute paths], count, waitedMs, timedOut: false}; " +
+                            "on timeout it returns the same shape with timedOut: true (matched may be empty). " +
+                            "Only files are matched (directories are searched through, not matched). " +
+                            "Only works within allowed directories.",
+                        inputSchema: zodToJsonSchema(WaitForFileArgsSchema),
+                    },
                 ],
             };
         });
@@ -396,7 +509,7 @@ export class FilesystemServer {
                         if (!parsed.success) {
                             throw new Error(`Invalid arguments for delete_files: ${parsed.error}`);
                         }
-                        const result = await handleDeleteFiles(parsed.data.paths, parsed.data.recursive, this.allowedDirectories);
+                        const result = await handleDeleteFiles(parsed.data.paths, parsed.data.recursive, this.allowedDirectories, parsed.data.toRecycleBin);
                         return {
                             content: [{ type: "text", text: result }],
                         };
@@ -478,6 +591,16 @@ export class FilesystemServer {
                                 }],
                         };
                     }
+                    case "create_link": {
+                        const parsed = CreateLinkArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for create_link: ${parsed.error}`);
+                        }
+                        const result = await handleCreateLink(parsed.data.target, parsed.data.linkPath, parsed.data.type, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
                     case "transfer_files": {
                         const parsed = MoveFilesArgsSchema.safeParse(args);
                         if (!parsed.success) {
@@ -503,7 +626,17 @@ export class FilesystemServer {
                         if (!parsed.success) {
                             throw new Error(`Invalid arguments for search_regex: ${parsed.error}`);
                         }
-                        const result = await handleSearchRegex(parsed.data.path, parsed.data.pattern, parsed.data.filePatterns, parsed.data.excludePatterns, parsed.data.maxResults, parsed.data.caseSensitive, parsed.data.offset, this.allowedDirectories);
+                        const result = await handleSearchRegex(parsed.data.path, parsed.data.pattern, parsed.data.filePatterns, parsed.data.excludePatterns, parsed.data.maxResults, parsed.data.caseSensitive, parsed.data.offset, this.allowedDirectories, parsed.data.countOnly);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "replace_regex": {
+                        const parsed = ReplaceRegexArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for replace_regex: ${parsed.error}`);
+                        }
+                        const result = await handleReplaceRegex(parsed.data.paths, parsed.data.pattern, parsed.data.replacement, parsed.data.flags, parsed.data.dryRun, this.allowedDirectories);
                         return {
                             content: [{ type: "text", text: result }],
                         };
@@ -676,12 +809,73 @@ export class FilesystemServer {
                             content: [{ type: "text", text: result }],
                         };
                     }
+                    case "launch_file": {
+                        const parsed = LaunchFileArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for launch_file: ${parsed.error}`);
+                        }
+                        const result = await handleLaunchFile(parsed.data.path, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "read_bytes": {
+                        const parsed = ReadBytesArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for read_bytes: ${parsed.error}`);
+                        }
+                        const result = await handleReadBytes(parsed.data.path, parsed.data.offset, parsed.data.length, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "write_bytes": {
+                        const parsed = WriteBytesArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for write_bytes: ${parsed.error}`);
+                        }
+                        const result = await handleWriteBytes(parsed.data.path, parsed.data.offset, parsed.data.dataBase64, parsed.data.extend, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "dir_diff": {
+                        const parsed = DirDiffArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for dir_diff: ${parsed.error}`);
+                        }
+                        const result = await handleDirDiff(parsed.data.dirA, parsed.data.dirB, parsed.data.ignore, parsed.data.maxFiles, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "convert_encoding": {
+                        const parsed = ConvertEncodingArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for convert_encoding: ${parsed.error}`);
+                        }
+                        const result = await handleConvertEncoding(parsed.data.path, parsed.data.to, parsed.data.from, parsed.data.outPath, parsed.data.overwrite, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
+                    case "wait_for_file": {
+                        const parsed = WaitForFileArgsSchema.safeParse(args);
+                        if (!parsed.success) {
+                            throw new Error(`Invalid arguments for wait_for_file: ${parsed.error}`);
+                        }
+                        const result = await handleWaitForFile(parsed.data.path, parsed.data.glob, parsed.data.timeoutMs, parsed.data.intervalMs, this.allowedDirectories);
+                        return {
+                            content: [{ type: "text", text: result }],
+                        };
+                    }
                     default:
                         throw new Error(`Unknown tool: ${name}`);
                 }
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Never surface the internal \\?\ long-path prefix in error text.
+                const errorMessage = stripLongPathAll(error instanceof Error ? error.message : String(error));
                 return {
                     content: [{ type: "text", text: `Error: ${errorMessage}` }],
                     isError: true,

package/dist/wait_for_file/handler.js

@@ -0,0 +1,91 @@
+import fs from "fs/promises";
+import path from "path";
+import { minimatch } from "minimatch";
+import { validatePath, stripLongPath } from "../helpers/path.js";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Recursively scan a directory tree and collect the files whose path relative
+// to `root` matches `pattern` (minimatch, dot:true - same machinery as search_glob).
+// Unreadable directories and entries that vanish mid-scan are skipped.
+// Only files are matched; directories are searched through.
+async function scanForMatches(root, pattern) {
+    const results = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // skip directories we can't read
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            try {
+                if (entry.isDirectory()) {
+                    await walk(fullPath);
+                    continue;
+                }
+                if (!entry.isFile()) {
+                    continue; // skip symlinks/devices/etc. - only real files are matched
+                }
+                // Normalize separators to '/' so minimatch matching is platform-consistent.
+                const relativePath = path.relative(root, fullPath).split(path.sep).join("/");
+                if (minimatch(relativePath, pattern, { dot: true })) {
+                    results.push(stripLongPath(fullPath));
+                }
+            }
+            catch {
+                // Skip anything that errors (e.g. raced with a deletion)
+                continue;
+            }
+        }
+    }
+    await walk(root);
+    results.sort();
+    return results;
+}
+export async function handleWaitForFile(baseDir, glob, timeoutMs, intervalMs, allowedDirectories) {
+    const validRoot = await validatePath(baseDir, allowedDirectories);
+    let stats;
+    try {
+        stats = await fs.stat(validRoot);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            throw new Error(`Base directory does not exist: ${baseDir}`);
+        }
+        throw error;
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`Not a directory: ${baseDir}`);
+    }
+    // On Windows, treat backslashes in the pattern as path separators so both
+    // 'a/b/*.txt' and 'a\b\*.txt' work (minimatch otherwise parses '\\' as an escape).
+    const pattern = process.platform === "win32" ? glob.split("\\").join("/") : glob;
+    const startedAt = Date.now();
+    const deadline = startedAt + timeoutMs;
+    let matched = [];
+    for (;;) {
+        matched = await scanForMatches(validRoot, pattern);
+        if (matched.length > 0) {
+            return JSON.stringify({
+                matched,
+                count: matched.length,
+                waitedMs: Date.now() - startedAt,
+                timedOut: false,
+            });
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            break;
+        }
+        // Async sleep keeps the server event loop responsive between polls.
+        await sleep(Math.min(intervalMs, remaining));
+    }
+    return JSON.stringify({
+        matched,
+        count: matched.length,
+        waitedMs: Date.now() - startedAt,
+        timedOut: true,
+    });
+}

package/dist/wait_for_file/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const WaitForFileArgsSchema = z.object({
+    path: z.string().describe("Base directory to watch (must be inside an allowed root). The glob is matched against each file's path relative to this directory."),
+    glob: z.string().describe("Glob pattern matched against each file's path relative to path (same glob machinery as search_glob: minimatch with dot:true; on Windows backslashes in the pattern are treated as path separators, so 'a\\b\\*.txt' and 'a/b/*.txt' both work)."),
+    timeoutMs: z.number().int().min(0).max(300000).optional().default(30000).describe("Maximum time to wait, in milliseconds (default 30000, max 300000)."),
+    intervalMs: z.number().int().min(100).max(300000).optional().default(500).describe("Poll interval, in milliseconds (default 500, min 100)."),
+});