mcp-fs-shell-windows 0.2.7 → 0.2.18

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";
@@ -26,6 +28,12 @@ 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";
@@ -49,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";
@@ -58,6 +67,12 @@ 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";
@@ -74,7 +89,7 @@ export class FilesystemServer {
         this.allowedDirectories = allowedDirectories;
         this.server = new Server({
             name: "secure-filesystem-server",
-            version: "0.2.7",
+            version: "0.2.18",
         }, {
             capabilities: {
                 tools: {},
@@ -93,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),
                     },
@@ -100,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.",
@@ -119,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),
                     },
@@ -153,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),
@@ -169,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),
@@ -182,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),
                     },
@@ -200,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. " +
@@ -240,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),
                     },
@@ -281,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. " +
@@ -364,6 +413,60 @@ export class FilesystemServer {
                             "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),
+                    },
                 ],
             };
         });
@@ -406,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 }],
                         };
@@ -488,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) {
@@ -513,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 }],
                         };
@@ -696,12 +819,63 @@ export class FilesystemServer {
                             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)."),
+});

package/dist/write_bytes/handler.js

@@ -0,0 +1,49 @@
+import fs from "fs/promises";
+import { validatePath } from "../helpers/path.js";
+// Strict base64: groups of 4, with valid padding at the end.
+const BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$/;
+export async function handleWriteBytes(filePath, offset, dataBase64, extend, allowedDirectories) {
+    const validPath = await validatePath(filePath, allowedDirectories);
+    let stats;
+    try {
+        stats = await fs.stat(validPath);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            throw new Error(`File does not exist (write_bytes requires an existing file, no implicit create): ${filePath}`);
+        }
+        throw error;
+    }
+    if (!stats.isFile()) {
+        throw new Error(`Not a file: ${filePath}`);
+    }
+    const size = stats.size;
+    if (!BASE64_RE.test(dataBase64)) {
+        throw new Error(`Invalid base64 in dataBase64: ${JSON.stringify(dataBase64.slice(0, 80))}`);
+    }
+    const data = Buffer.from(dataBase64, "base64");
+    const end = offset + data.length;
+    const handle = await fs.open(validPath, "r+");
+    try {
+        if (end > size) {
+            if (!extend) {
+                throw new Error(`Write would extend file past EOF: offset ${offset} + ${data.length} bytes = ${end} > file size ${size}; use extend=true to grow the file`);
+            }
+            await handle.truncate(end);
+        }
+        const { bytesWritten } = await handle.write(data, 0, data.length, offset);
+        if (bytesWritten !== data.length) {
+            throw new Error(`Short write: expected ${data.length} bytes at offset ${offset}, wrote ${bytesWritten}`);
+        }
+    }
+    finally {
+        await handle.close();
+    }
+    return JSON.stringify({
+        path: filePath,
+        offset,
+        bytesWritten: data.length,
+        size: Math.max(size, end),
+    });
+}

package/dist/write_bytes/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const WriteBytesArgsSchema = z.object({
+    path: z.string().describe("Path to the file to write (must already exist - no implicit create)"),
+    offset: z.number().int().min(0).describe("Byte offset at which to write (0-indexed)"),
+    dataBase64: z.string().describe("Base64-encoded bytes to write. Must be valid base64 (strict)."),
+    extend: z.boolean().optional().default(false).describe("If true, grow the file when the write ends past EOF, zero-filling any gap between the old size and the offset. Default: false (write past EOF is an error)."),
+});

package/dist/write_new_files/handler.js

@@ -1,6 +1,7 @@
 import fs from "fs/promises";
 import path from "path";
-import { validatePath, ensureDirectoryExists } from "../helpers/path.js";
+import { validatePath, ensureDirectoryExists, stripLongPathAll } from "../helpers/path.js";
+import { encodeText } from "../helpers/encoding.js";
 export async function handleWriteNewFiles(files, allowedDirectories) {
     const results = [];
     const errors = [];
@@ -30,12 +31,14 @@ export async function handleWriteNewFiles(files, allowedDirectories) {
                 await fs.writeFile(validPath, Buffer.from(file.content, "base64"));
             }
             else {
-                await fs.writeFile(validPath, file.content, "utf-8");
+                // textEncoding defaults to utf8 (byte-identical to the old behavior);
+                // base64 above already handled the raw-bytes case.
+                await fs.writeFile(validPath, encodeText(file.content, file.textEncoding ?? "utf8"));
             }
             results.push(`Successfully wrote to ${file.path}${file.overwrite ? " (overwritten)" : ""}`);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorMessage = stripLongPathAll(error instanceof Error ? error.message : String(error));
             errors.push(`Failed to write file ${file.path}: ${errorMessage}`);
         }
     }));

package/dist/write_new_files/schema.js

@@ -5,5 +5,6 @@ export const WriteNewFilesArgsSchema = z.object({
         content: z.string().describe("Content to write to the file (UTF-8 text, or base64 when encoding is \"base64\")"),
         overwrite: z.boolean().optional().default(false).describe("Replace the file if it already exists. Default: false (fail if it exists)."),
         encoding: z.enum(["utf8", "base64"]).optional().default("utf8").describe("Content encoding. Use \"base64\" for binary files."),
+        textEncoding: z.enum(["utf8", "utf16le", "utf16be", "cp1252"]).optional().describe("Text encoding for text content: 'utf8' (default), 'utf16le' or 'utf16be' (a BOM is written), or 'cp1252' (no BOM). Ignored when encoding is \"base64\" (raw bytes win)."),
     })).describe("Array of files to write"),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-fs-shell-windows",
-  "version": "0.2.7",
+  "version": "0.2.18",
   "description": "MCP filesystem server: batched file tools + standalone Windows shell tools (extended fork)",
   "license": "MIT",
   "author": "Gerard DeLuca",