@j0hanz/filesystem-mcp 1.12.0 → 1.13.1

package/dist/completions.js

@@ -47,6 +47,9 @@ const PATH_ARGUMENTS = new Set([
 const DESTINATION_CONTEXT_KEYS = ['source', 'path', 'cwd', 'root'];
 const PRIMARY_PATH_CONTEXT_KEYS = ['path', 'cwd', 'root'];
 const DEFAULT_CONTEXT_KEYS = ['path', 'source', 'cwd', 'root'];
+const ENUM_ARGUMENT_VALUES = new Map([
+    ['sortby', ['modified', 'name', 'path', 'size', 'type']],
+]);
 function isPathLikeArgumentName(argName) {
     return (PATH_ARGUMENTS.has(argName) ||
         argName.endsWith('paths') ||
@@ -56,6 +59,16 @@ function isPathLikeArgumentName(argName) {
         argName.endsWith('dirs') ||
         argName.endsWith('dir'));
 }
+function getEnumCompletions(argName, currentValue) {
+    const values = ENUM_ARGUMENT_VALUES.get(argName);
+    if (!values)
+        return undefined;
+    const prefix = currentValue.toLowerCase();
+    const filtered = prefix
+        ? values.filter((v) => v.startsWith(prefix))
+        : [...values];
+    return buildCompletionResult(filtered);
+}
 function isTemplateVariableChar(char) {
     const code = char.charCodeAt(0);
     const isDigit = code >= 48 && code <= 57;
@@ -452,6 +465,10 @@ export function registerCompletions(server, instructions = '') {
                 : toolNameValues;
             return buildCompletionResponse(buildCompletionResult(filtered));
         }
+        const enumResult = getEnumCompletions(argName, argument.value);
+        if (enumResult) {
+            return buildCompletionResponse(enumResult);
+        }
         const isPathArg = isPathLikeArgumentName(argName) ||
             isPathArgumentFromReference(argName, ref);
         if (!isPathArg) {

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) {
@@ -169,15 +185,16 @@ function buildEditCompletionMessage(args, result) {
     const added = structuredContent.linesAdded ?? 0;
     const removed = structuredContent.linesRemoved ?? 0;
     const dry = args.dryRun ? 'dry run ' : '';
-    return `🛠 edit: ${name} • ${dry}+${added} -${removed}`;
+    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/replace-in-files.js

@@ -1,6 +1,8 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Buffer } from 'node:buffer';
+import { performance } from 'node:perf_hooks';
 import { createTwoFilesPatch } from 'diff';
 import RE2 from 're2';
 import safeRegex from 'safe-regex2';
@@ -110,6 +112,13 @@ class LiteralReplacementMatcher {
         return content.replaceAll(this.searchPattern, () => replacement);
     }
 }
+const replaceContextStorage = new AsyncLocalStorage();
+function getReplaceContext() {
+    const ctx = replaceContextStorage.getStore();
+    if (!ctx)
+        throw new Error('Replace context not found in AsyncLocalStorage');
+    return ctx;
+}
 function buildReplacementPlan(content, replacement, matcher) {
     const matchCount = matcher.count(content);
     if (matchCount === 0) {
@@ -124,8 +133,8 @@ function buildReplacementPlan(content, replacement, matcher) {
 function formatFileTooLargeError(filePath, size, maxFileSize) {
     return `File too large: ${filePath} (${size} bytes > ${maxFileSize} bytes)`;
 }
-async function processEntry(entryPath, context) {
-    const { options, replacement, matcher, maxFileSize, signal, summary } = context;
+async function processEntry(entryPath) {
+    const { options, signal, summary } = getReplaceContext();
     let validPath;
     try {
         validPath = await validatePathForWrite(entryPath, signal);
@@ -139,12 +148,7 @@ async function processEntry(entryPath, context) {
         return;
     }
     try {
-        const plan = await readReplacementPlan(validPath, {
-            matcher,
-            replacement,
-            maxFileSize,
-            signal,
-        });
+        const plan = await readReplacementPlan(validPath);
         if (!plan) {
             return;
         }
@@ -172,19 +176,20 @@ async function processEntry(entryPath, context) {
         });
     }
 }
-async function readReplacementPlan(validPath, context) {
+async function readReplacementPlan(validPath) {
+    const { matcher, replacement, maxFileSize, signal } = getReplaceContext();
     let fileHandle;
     try {
         const fd = await fs.open(validPath, 'r');
         fileHandle = fd;
         const stats = await fileHandle.stat();
-        if (stats.size > context.maxFileSize) {
-            throw new Error(formatFileTooLargeError(validPath, stats.size, context.maxFileSize));
+        if (stats.size > maxFileSize) {
+            throw new Error(formatFileTooLargeError(validPath, stats.size, maxFileSize));
         }
         let content;
-        if (context.matcher.testBuffer) {
-            const buffer = await fileHandle.readFile({ signal: context.signal });
-            if (!context.matcher.testBuffer(buffer)) {
+        if (matcher.testBuffer) {
+            const buffer = await fileHandle.readFile({ signal });
+            if (!matcher.testBuffer(buffer)) {
                 return undefined;
             }
             content = buffer.toString('utf-8');
@@ -192,10 +197,10 @@ async function readReplacementPlan(validPath, context) {
         else {
             content = await fileHandle.readFile({
                 encoding: 'utf-8',
-                signal: context.signal,
+                signal,
             });
         }
-        return buildReplacementPlan(content, context.replacement, context.matcher);
+        return buildReplacementPlan(content, replacement, matcher);
     }
     finally {
         if (fileHandle) {
@@ -211,10 +216,13 @@ async function maybeAppendPatchDiff(summary, params) {
         return;
     }
     const patch = await new Promise((resolve) => {
-        createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified', {
-            callback: (res) => {
-                resolve(res ?? '');
-            },
+        // Defer to event loop to avoid blocking on large diffs
+        setImmediate(() => {
+            createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified', {
+                callback: (res) => {
+                    resolve(res ?? '');
+                },
+            });
         });
     });
     if (summary.diff.length + patch.length <=
@@ -315,7 +323,22 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
         suppressErrors: true,
     });
     const summary = createReplaceSummary(root);
-    const { stoppedByLimit } = await processEntriesConcurrently(entries, {
+    const timerStartName = `searchAndReplaceStart_${Date.now()}`;
+    const timerEndName = `searchAndReplaceEnd_${Date.now()}`;
+    const metricName = `searchAndReplace_${Date.now()}`;
+    performance.mark(timerStartName);
+    const context = {
+        options: {
+            dryRun: args.dryRun,
+            returnDiff: args.returnDiff ?? false,
+        },
+        replacement: args.replacement,
+        matcher,
+        maxFileSize,
+        signal,
+        summary,
+    };
+    const { stoppedByLimit } = await replaceContextStorage.run(context, () => processEntriesConcurrently(entries, {
         signal,
         concurrency: REPLACE_CONCURRENCY,
         ...(args.maxFiles !== undefined ? { maxEntries: args.maxFiles } : {}),
@@ -325,18 +348,15 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
                 throttleModulo: 25,
             });
         },
-        runEntry: async (entryPath) => processEntry(entryPath, {
-            options: {
-                dryRun: args.dryRun,
-                returnDiff: args.returnDiff ?? false,
-            },
-            replacement: args.replacement,
-            matcher,
-            maxFileSize,
-            signal,
-            summary,
-        }),
-    });
+        runEntry: processEntry,
+    }));
+    performance.mark(timerEndName);
+    performance.measure(metricName, timerStartName, timerEndName);
+    const durationMs = performance.getEntriesByName(metricName)[0]?.duration ?? 0;
+    performance.clearMarks(timerStartName);
+    performance.clearMarks(timerEndName);
+    performance.clearMeasures(metricName);
+    summary.perfTimeMs = durationMs;
     if (stoppedByLimit) {
         summary.stoppedReason = 'maxFiles';
     }
@@ -394,7 +414,10 @@ export function registerSearchAndReplaceTool(server, options = {}) {
 function buildSearchAndReplaceText(summary, dryRun) {
     const failureSuffix = summary.failedFiles > 0 ? ` (${summary.failedFiles} failed)` : '';
     const dryRunSuffix = dryRun ? ' (Dry run)' : '';
-    return `Found ${summary.totalMatches} matches in ${summary.filesChanged} files${failureSuffix}.${dryRunSuffix}`;
+    const timing = summary.perfTimeMs
+        ? ` [\u23F1\uFE0F ${summary.perfTimeMs.toFixed(0)}ms]`
+        : '';
+    return `Found ${summary.totalMatches} matches in ${summary.filesChanged} files${failureSuffix}.${dryRunSuffix}${timing}`;
 }
 function buildSearchAndReplaceStructuredResult(summary, args) {
     return {

package/dist/tools/search-content.js

@@ -1,9 +1,10 @@
 import * as path from 'node:path';
+import { performance } from 'node:perf_hooks';
 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';
@@ -18,6 +19,7 @@ const CONFIG = {
         maxFiles: 'max files',
     },
 };
+let searchMetricSequence = 0;
 const TRUTHY_SUMMARY_FIELDS = [
     'filesMatched',
     'skippedTooLarge',
@@ -26,15 +28,20 @@ const TRUTHY_SUMMARY_FIELDS = [
     'linesSkippedDueToRegexTimeout',
 ];
 function buildStructuredSummaryFields(summary) {
-    const truthyFields = Object.fromEntries(TRUTHY_SUMMARY_FIELDS.flatMap((key) => {
+    const result = {};
+    for (const key of TRUTHY_SUMMARY_FIELDS) {
         const value = summary[key];
-        return value ? [[key, value]] : [];
-    }));
-    return {
-        ...truthyFields,
-        ...(summary.truncated ? { truncated: true } : {}),
-        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
-    };
+        if (value) {
+            result[key] = value;
+        }
+    }
+    if (summary.truncated) {
+        result.truncated = true;
+    }
+    if (summary.stoppedReason) {
+        result.stoppedReason = summary.stoppedReason;
+    }
+    return result;
 }
 function buildCompletionSuffix(count, filesMatched, scope, stoppedReason) {
     if (count === 0)
@@ -46,6 +53,15 @@ function buildCompletionSuffix(count, filesMatched, scope, stoppedReason) {
         : '';
     return `${count} ${matchWord} in ${filesMatched} ${fileWord}${reasonSuffix}`;
 }
+function createSearchMetricNames() {
+    searchMetricSequence += 1;
+    const metricSuffix = `${Date.now()}_${searchMetricSequence}`;
+    return {
+        timerStartName: `searchContentStart_${metricSuffix}`,
+        timerEndName: `searchContentEnd_${metricSuffix}`,
+        metricName: `searchContent_${metricSuffix}`,
+    };
+}
 function compareNormalizedMatches(left, right) {
     const fileCompare = left.relativeFile.localeCompare(right.relativeFile);
     if (fileCompare !== 0)
@@ -157,12 +173,13 @@ const SearchResponseBuilder = {
         });
     },
     buildMatchList(heading, matches) {
-        const lines = [heading];
+        if (matches.length === 0)
+            return heading;
+        const parts = [heading];
         for (const match of matches) {
-            const lineNum = String(match.line).padStart(4);
-            lines.push(`  ${match.relativeFile}:${lineNum}: ${match.content}`);
+            parts.push(`\n  ${match.relativeFile}:${String(match.line).padStart(4)}: ${match.content}`);
         }
-        return joinLines(lines);
+        return parts.join('');
     },
     resolveTruncatedReason(summary) {
         if (summary.stoppedReason === 'timeout')
@@ -195,6 +212,7 @@ const SearchResponseBuilder = {
 const SearchExecutor = {
     async run(args, basePath, signal, onProgress) {
         const excludePatterns = args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS;
+        const { timerStartName, timerEndName, metricName } = createSearchMetricNames();
         const options = {
             includeHidden: args.includeHidden,
             excludePatterns,
@@ -208,6 +226,7 @@ const SearchExecutor = {
             ...(signal ? { signal } : {}),
             ...(onProgress ? { onProgress } : {}),
         };
+        performance.mark(timerStartName);
         try {
             return await searchContent(basePath, args.pattern, options);
         }
@@ -217,6 +236,13 @@ const SearchExecutor = {
             }
             throw error;
         }
+        finally {
+            performance.mark(timerEndName);
+            performance.measure(metricName, timerStartName, timerEndName);
+            performance.clearMarks(timerStartName);
+            performance.clearMarks(timerEndName);
+            performance.clearMeasures(metricName);
+        }
     },
     createMatcher(args) {
         if (!args.isRegex)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.12.0",
+  "version": "1.13.1",
   "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",