@j0hanz/filesystem-mcp 1.12.0 → 1.13.0

package/dist/lib/utils.d.ts

@@ -1,4 +1,8 @@
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function debounce<Args extends unknown[]>(func: (...args: Args) => void, waitMs: number): {
+    (...args: Args): void;
+    cancel: () => void;
+};
 export declare function mergeOptions<T extends object>(defaults: T, overrides: Partial<T>): T;
 export declare function omitOptionKeys<T extends object, K extends keyof T>(input: T, keys: readonly K[]): Omit<T, K>;
 export declare function setIfDefined<T extends object, K extends keyof T>(target: T, key: K, value: T[K] | undefined): void;

package/dist/lib/utils.js

@@ -2,6 +2,32 @@
 export function isRecord(value) {
     return value !== null && typeof value === 'object';
 }
+// debounce
+export function debounce(func, waitMs) {
+    let timeoutId;
+    const debounced = (...args) => {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            timeoutId = undefined;
+            func(...args);
+        }, waitMs);
+        // Unref if in Node environment to not block process exit
+        const nodeTimeout = timeoutId;
+        if (typeof nodeTimeout === 'object' &&
+            typeof nodeTimeout.unref === 'function') {
+            nodeTimeout.unref();
+        }
+    };
+    debounced.cancel = () => {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+    };
+    return debounced;
+}
 // option-utils.ts
 export function mergeOptions(defaults, overrides) {
     return { ...defaults, ...overrides };

package/dist/server/roots-manager.d.ts

@@ -3,7 +3,7 @@ import { type AllowedDirectoriesState } from '../lib/paths.js';
 import { type LoggingState } from './bootstrap.js';
 import type { ServerOptions } from './bootstrap.js';
 export declare class RootsManager {
-    private rootsUpdateTimeout;
+    private _debouncedUpdate;
     private rootDirectories;
     private allowedDirectoriesState;
     private clientInitialized;

package/dist/server/roots-manager.js

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
 import { getValidRootDirectories, isPathWithinDirectories, normalizePath, resolveAllowedDirectoriesState, setAllowedDirectoriesStateResolved, } from '../lib/paths.js';
-import { isRecord } from '../lib/utils.js';
+import { debounce, isRecord } from '../lib/utils.js';
 import { logToMcp } from './bootstrap.js';
 const ROOTS_TIMEOUT_MS = 5000;
 const ROOTS_DEBOUNCE_MS = 100;
@@ -81,7 +81,7 @@ async function filterRootsWithinBaseline(roots, baseline, signal) {
     });
 }
 export class RootsManager {
-    rootsUpdateTimeout;
+    _debouncedUpdate;
     rootDirectories = [];
     allowedDirectoriesState = {
         primary: [],
@@ -102,9 +102,9 @@ export class RootsManager {
         return this.clientInitialized;
     }
     destroy() {
-        if (this.rootsUpdateTimeout) {
-            clearTimeout(this.rootsUpdateTimeout);
-            this.rootsUpdateTimeout = undefined;
+        if (this._debouncedUpdate) {
+            this._debouncedUpdate.cancel();
+            this._debouncedUpdate = undefined;
         }
     }
     getAllowedDirectoriesState() {
@@ -149,15 +149,10 @@ export class RootsManager {
         }
     }
     scheduleRootsUpdate(server) {
-        if (this.rootsUpdateTimeout) {
-            this.rootsUpdateTimeout.refresh();
-            return;
-        }
-        this.rootsUpdateTimeout = setTimeout(() => {
-            this.rootsUpdateTimeout = undefined;
-            void this.updateRootsFromClient(server);
+        this._debouncedUpdate ??= debounce((s) => {
+            void this.updateRootsFromClient(s);
         }, ROOTS_DEBOUNCE_MS);
-        this.rootsUpdateTimeout.unref();
+        this._debouncedUpdate(server);
     }
     logMissingDirectories(server) {
         if (this.options.allowCwd) {

package/dist/tools/apply-patch.js

@@ -1,9 +1,9 @@
 import * as path from 'node:path';
 import { readFile, stat } from 'node:fs/promises';
 import { applyPatch, parsePatch } from 'diff';
-import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
+import { MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
-import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
+import { atomicWriteFile, processInParallel, withAbort, } from '../lib/fs-helpers.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
@@ -82,29 +82,31 @@ async function applyDiff(filePath, diff, options, signal) {
 }
 async function processMultiFilePatch(basePath, parsed, options, signal) {
     const validBase = await validateExistingPath(basePath, signal);
-    const promises = parsed.map(async (diff) => {
+    const promises = parsed.map((diff) => {
         const fileName = extractPatchTargetPath(diff);
         if (!fileName) {
-            return {
+            return () => Promise.resolve({
                 path: '<unknown>',
                 applied: false,
                 error: 'Missing file name in patch header',
-            };
+            });
         }
         const filePath = path.resolve(validBase, fileName);
-        try {
-            const result = await applyDiff(filePath, diff, options, signal);
-            return { ...result, path: fileName };
-        }
-        catch (error) {
-            return {
-                path: fileName,
-                applied: false,
-                error: formatUnknownErrorMessage(error),
-            };
-        }
+        return async () => {
+            try {
+                const result = await applyDiff(filePath, diff, options, signal);
+                return { ...result, path: fileName };
+            }
+            catch (error) {
+                return {
+                    path: fileName,
+                    applied: false,
+                    error: formatUnknownErrorMessage(error),
+                };
+            }
+        };
     });
-    const results = await Promise.all(promises);
+    const { results } = await processInParallel(promises, (task) => task(), PARALLEL_CONCURRENCY, signal);
     const totals = results.reduce((acc, r) => {
         if (r.applied) {
             acc.applied++;

package/dist/tools/edit-file.js

@@ -40,24 +40,34 @@ function getLineNumberAtIndex(str, maxIndex = str.length) {
 function countLines(str) {
     return getLineNumberAtIndex(str);
 }
-function computeDiffStats(original, modified) {
-    const changes = diffLines(original, modified);
-    let linesAdded = 0;
-    let linesRemoved = 0;
-    for (const part of changes) {
-        if (part.added) {
-            linesAdded += part.count;
-        }
-        else if (part.removed) {
-            linesRemoved += part.count;
-        }
-    }
-    return { linesAdded, linesRemoved };
+async function computeDiffStats(original, modified) {
+    return new Promise((resolve) => {
+        diffLines(original, modified, {
+            callback: (changes) => {
+                let linesAdded = 0;
+                let linesRemoved = 0;
+                for (const part of changes) {
+                    if (part.added) {
+                        linesAdded += part.count;
+                    }
+                    else if (part.removed) {
+                        linesRemoved += part.count;
+                    }
+                }
+                resolve({ linesAdded, linesRemoved });
+            },
+        });
+    });
 }
-function findEditMatch(content, oldText, ignoreWhitespace) {
+function findEditMatch(content, oldText, ignoreWhitespace, regexCache) {
     if (ignoreWhitespace) {
         const pattern = escapeRegExp(oldText).replace(/\s+/g, '\\s+');
-        const regex = new RE2(pattern);
+        let regex = regexCache?.get(pattern);
+        if (!regex) {
+            regex = new RE2(pattern);
+            if (regexCache)
+                regexCache.set(pattern, regex);
+        }
         const match = regex.exec(content);
         if (!match) {
             return undefined;
@@ -109,9 +119,9 @@ function buildStructuredEditOutput(validPath, result) {
         ...(result.lineRange ? { lineRange: result.lineRange } : {}),
     };
 }
-function finalizeEditResult(originalContent, updatedContent, appliedEdits, unmatchedEdits, lineRange) {
+async function finalizeEditResult(originalContent, updatedContent, appliedEdits, unmatchedEdits, lineRange) {
     const { linesAdded, linesRemoved } = appliedEdits > 0
-        ? computeDiffStats(originalContent, updatedContent)
+        ? await computeDiffStats(originalContent, updatedContent)
         : { linesAdded: 0, linesRemoved: 0 };
     return {
         content: updatedContent,
@@ -122,9 +132,15 @@ function finalizeEditResult(originalContent, updatedContent, appliedEdits, unmat
         ...(lineRange ? { lineRange } : {}),
     };
 }
-function buildDiff(validPath, original, modified) {
+async function buildDiff(validPath, original, modified) {
     const fileName = basename(validPath);
-    return createTwoFilesPatch(fileName, fileName, original, modified, 'Original', 'Modified');
+    return new Promise((resolve) => {
+        createTwoFilesPatch(fileName, fileName, original, modified, 'Original', 'Modified', {
+            callback: (res) => {
+                resolve(res ?? '');
+            },
+        });
+    });
 }
 function formatUnmatchedEditsNote(unmatchedEdits) {
     if (unmatchedEdits.length === 0) {
@@ -171,13 +187,14 @@ function buildEditCompletionMessage(args, result) {
     const dry = args.dryRun ? 'dry run ' : '';
     return `🛠 edit: ${name} • ${dry}+${added} -${removed}`;
 }
-function applyEdits(content, edits, ignoreWhitespace) {
+async function applyEdits(content, edits, ignoreWhitespace) {
     let newContent = content;
     let appliedEdits = 0;
     const unmatchedEdits = [];
     let lineRange;
+    const regexCache = ignoreWhitespace ? new Map() : undefined;
     for (const edit of edits) {
-        const match = findEditMatch(newContent, edit.oldText, ignoreWhitespace);
+        const match = findEditMatch(newContent, edit.oldText, ignoreWhitespace, regexCache);
         if (!match) {
             unmatchedEdits.push(edit.oldText);
             continue;
@@ -190,11 +207,11 @@ function applyEdits(content, edits, ignoreWhitespace) {
 }
 export async function handleEditFile(args, signal) {
     const { validPath, content } = await loadEditableFile(args.path, signal);
-    const editResult = applyEdits(content, args.edits, args.ignoreWhitespace);
+    const editResult = await applyEdits(content, args.edits, args.ignoreWhitespace);
     const structured = buildStructuredEditOutput(validPath, editResult);
     if (args.dryRun) {
         if (editResult.appliedEdits > 0) {
-            structured.diff = buildDiff(validPath, content, editResult.content);
+            structured.diff = await buildDiff(validPath, content, editResult.content);
         }
         return buildToolResponse(`Dry run complete. ${editResult.appliedEdits} edits would be applied.`, structured);
     }

package/dist/tools/search-content.js

@@ -3,7 +3,7 @@ import RE2 from 're2';
 import { DEFAULT_EXCLUDE_PATTERNS } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
 import { searchContent } from '../lib/file-operations/search.js';
-import { formatOperationSummary, joinLines } from '../config.js';
+import { formatOperationSummary } from '../config.js';
 import { SearchContentInputSchema, SearchContentOutputSchema, } from '../schemas.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
@@ -157,12 +157,32 @@ const SearchResponseBuilder = {
         });
     },
     buildMatchList(heading, matches) {
-        const lines = [heading];
+        if (matches.length === 0)
+            return heading;
+        // Fast path: calculate exact byte length to avoid arrays and string concatenation in V8
+        // +1 for newline after heading. Each match gets: "  " (2) + relativeFile + ":" + line + ": " (2) + content + "\n"
+        let totalBytes = Buffer.byteLength(heading, 'utf8');
+        for (const match of matches) {
+            totalBytes +=
+                1 + // \n
+                    2 + // "  "
+                    Buffer.byteLength(match.relativeFile, 'utf8') +
+                    1 + // ":"
+                    Math.max(4, String(match.line).length) +
+                    2 + // ": "
+                    Buffer.byteLength(match.content, 'utf8');
+        }
+        const buf = Buffer.allocUnsafe(totalBytes);
+        let offset = buf.write(heading, 0, 'utf8');
         for (const match of matches) {
-            const lineNum = String(match.line).padStart(4);
-            lines.push(`  ${match.relativeFile}:${lineNum}: ${match.content}`);
+            offset += buf.write('\n  ', offset, 'utf8');
+            offset += buf.write(match.relativeFile, offset, 'utf8');
+            offset += buf.write(':', offset, 'utf8');
+            offset += buf.write(String(match.line).padStart(4), offset, 'utf8');
+            offset += buf.write(': ', offset, 'utf8');
+            offset += buf.write(match.content, offset, 'utf8');
         }
-        return joinLines(lines);
+        return buf.toString('utf8', 0, offset);
     },
     resolveTruncatedReason(summary) {
         if (summary.stoppedReason === 'timeout')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "A local filesystem MCP server that lets LLMs and AI agents read, write, search, diff, patch, and manage files safely and efficiently. Built for reliable, structured, and controlled filesystem interaction.",
   "type": "module",