@j0hanz/filesystem-mcp 1.2.1 → 1.2.2

package/dist/cli.js

@@ -3,11 +3,13 @@ import { getSystemErrorMessage, getSystemErrorName } from 'node:util';
 import { z } from 'zod';
 import { Command, CommanderError, InvalidArgumentError } from 'commander';
 import packageJsonRaw from '../package.json' with { type: 'json' };
+import { processInParallel } from './lib/fs-helpers.js';
 import { getReservedDeviceNameForPath, isWindowsDriveRelativePath, normalizePath, } from './lib/path-validation.js';
 import { isRecord } from './lib/type-guards.js';
 const PackageJsonSchema = z.object({ version: z.string() });
 const { version: SERVER_VERSION } = PackageJsonSchema.parse(packageJsonRaw);
 const IS_WINDOWS = process.platform === 'win32';
+const CLI_VALIDATE_CONCURRENCY = 8;
 export class CliExitError extends Error {
     exitCode;
     constructor(message, exitCode) {
@@ -92,11 +94,17 @@ async function validateDirectoryPath(inputPath) {
     }
 }
 async function normalizeCliDirectories(args) {
-    const validations = [];
-    for (const arg of args) {
-        validations.push(validateDirectoryPath(arg));
+    const { results, errors } = await processInParallel([...args], validateDirectoryPath, CLI_VALIDATE_CONCURRENCY);
+    if (errors.length === 0) {
+        return results;
+    }
+    let first = errors[0];
+    for (const failure of errors) {
+        if (first && failure.index < first.index) {
+            first = failure;
+        }
     }
-    return Promise.all(validations);
+    throw first?.error ?? new Error('Failed to validate directories');
 }
 function parseAllowedDirArgument(value, previous) {
     validateCliPath(value);

package/dist/lib/resource-store.js

@@ -85,7 +85,7 @@ export function createInMemoryResourceStore(options = {}) {
     function getText(uri) {
         const existing = byUri.get(uri);
         if (!existing) {
-            throw new McpError(ErrorCode.E_NOT_FOUND, `Resource not found: ${uri}`);
+            throw new McpError(ErrorCode.E_NOT_FOUND, `Resource not found: ${uri}. The cached result may have been evicted. Re-run the originating tool to regenerate.`);
         }
         return existing;
     }

package/dist/server.js

@@ -300,35 +300,6 @@ export async function createServer(options = {}) {
     registerGetHelpPrompt(server, serverInstructions, localIcon);
     registerResultResources(server, resourceStore, localIcon);
     registerCompletions(server);
-    {
-        const stripStructured = process.env['FS_CONTEXT_STRIP_STRUCTURED'] !== '0';
-        if (stripStructured) {
-            const typedServer = server;
-            const origReg = typedServer.registerTool.bind(server);
-            typedServer.registerTool = (...regArgs) => {
-                // Strip outputSchema so SDK won't require structuredContent
-                if (regArgs.length >= 2 &&
-                    regArgs[1] &&
-                    typeof regArgs[1] === 'object') {
-                    const config = { ...regArgs[1] };
-                    delete config['outputSchema'];
-                    regArgs[1] = config;
-                }
-                const handlerIdx = regArgs.length - 1;
-                const origHandler = regArgs[handlerIdx];
-                if (typeof origHandler !== 'function')
-                    return origReg(...regArgs);
-                regArgs[handlerIdx] = async (...hArgs) => {
-                    const r = await origHandler(...hArgs);
-                    if (!r || typeof r !== 'object')
-                        return r;
-                    const record = r;
-                    return Object.fromEntries(Object.entries(record).filter(([key]) => key !== 'structuredContent'));
-                };
-                return origReg(...regArgs);
-            };
-        }
-    }
     registerAllTools(server, {
         resourceStore,
         isInitialized: () => rootsManager.isInitialized(),

package/dist/tools/apply-patch.js

@@ -73,7 +73,20 @@ export function registerApplyPatchTool(server, options = {}) {
         guard: options.isInitialized,
         progressMessage: (args) => {
             const name = path.basename(args.path);
-            return `🛠 apply_patch: ${name}`;
+            return args.dryRun
+                ? `🛠 apply_patch: ${name} [dry run]`
+                : `🛠 apply_patch: ${name}`;
+        },
+        completionMessage: (args, result) => {
+            const name = path.basename(args.path);
+            if (result.isError)
+                return `🛠 apply_patch: ${name} • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `🛠 apply_patch: ${name} • failed`;
+            if (args.dryRun)
+                return `🛠 apply_patch: ${name} • dry run OK`;
+            return `🛠 apply_patch: ${name} • applied`;
         },
     });
     if (registerToolTaskIfAvailable(server, 'apply_patch', APPLY_PATCH_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))

package/dist/tools/calculate-hash.js

@@ -153,20 +153,54 @@ export function registerCalculateHashTool(server, options = {}) {
         timedSignal: {},
         context: { path: args.path },
         run: async (signal) => {
+            const baseName = path.basename(args.path);
+            let progressCursor = 0;
             notifyProgress(extra, {
                 current: 0,
-                message: `🕮 calculate_hash: ${path.basename(args.path)}`,
+                message: `🕮 calculate_hash: ${baseName}`,
             });
-            const result = await handleCalculateHash(args, signal, createProgressReporter(extra));
-            const sc = result.structuredContent;
-            const totalFiles = sc.ok ? (sc.fileCount ?? 1) : 1;
-            const finalCurrent = totalFiles + 1;
-            const suffix = sc.ok ? `${(sc.hash ?? '').slice(0, 8)}...` : 'failed';
-            notifyProgress(extra, {
-                current: finalCurrent,
-                message: `🕮 calculate_hash: ${path.basename(args.path)} ➟ ${suffix}`,
-            });
-            return result;
+            const baseReporter = createProgressReporter(extra);
+            const progressWithMessage = ({ current, total, }) => {
+                if (current > progressCursor)
+                    progressCursor = current;
+                const fileWord = current === 1 ? 'file' : 'files';
+                baseReporter({
+                    current,
+                    ...(total !== undefined ? { total } : {}),
+                    message: `🕮 calculate_hash: ${baseName} — ${current} ${fileWord} hashed`,
+                });
+            };
+            try {
+                const result = await handleCalculateHash(args, signal, progressWithMessage);
+                const sc = result.structuredContent;
+                const totalFiles = sc.ok ? (sc.fileCount ?? 1) : 1;
+                const finalCurrent = Math.max(totalFiles + 1, progressCursor + 1);
+                let suffix;
+                if (!sc.ok) {
+                    suffix = 'failed';
+                }
+                else if (sc.fileCount !== undefined && sc.fileCount > 1) {
+                    suffix = `${sc.fileCount} files • ${(sc.hash ?? '').slice(0, 8)}...`;
+                }
+                else {
+                    suffix = `${(sc.hash ?? '').slice(0, 8)}...`;
+                }
+                notifyProgress(extra, {
+                    current: finalCurrent,
+                    total: finalCurrent,
+                    message: `🕮 calculate_hash: ${baseName} • ${suffix}`,
+                });
+                return result;
+            }
+            catch (error) {
+                const finalCurrent = Math.max(progressCursor + 1, 1);
+                notifyProgress(extra, {
+                    current: finalCurrent,
+                    total: finalCurrent,
+                    message: `🕮 calculate_hash: ${baseName} • failed`,
+                });
+                throw error;
+            }
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
     });

package/dist/tools/create-directory.js

@@ -32,7 +32,16 @@ export function registerCreateDirectoryTool(server, options = {}) {
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
-        progressMessage: (args) => `🛠 mkdir: ${path.basename(args.path)}`,
+        progressMessage: (args) => {
+            const name = path.basename(args.path) || args.path;
+            return `🛠 mkdir: ${name}`;
+        },
+        completionMessage: (args, result) => {
+            const name = path.basename(args.path) || args.path;
+            if (result.isError)
+                return `🛠 mkdir: ${name} • failed`;
+            return `🛠 mkdir: ${name} • created`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'mkdir', CREATE_DIRECTORY_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/dist/tools/diff-files.js

@@ -87,5 +87,18 @@ export function registerDiffFilesTool(server, options = {}) {
             const name2 = path.basename(args.modified);
             return `🕮 diff_files: ${name1} ⟷ ${name2}`;
         },
+        completionMessage: (args, result) => {
+            const n1 = path.basename(args.original);
+            const n2 = path.basename(args.modified);
+            if (result.isError)
+                return `🕮 diff_files: ${n1} ⟷ ${n2} • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `🕮 diff_files: ${n1} ⟷ ${n2} • failed`;
+            if (sc.isIdentical)
+                return `🕮 diff_files: ${n1} ⟷ ${n2} • identical`;
+            const hunks = (sc.diff?.match(/@@/g) ?? []).length;
+            return `🕮 diff_files: ${n1} ⟷ ${n2} • ${hunks} hunk${hunks !== 1 ? 's' : ''}`;
+        },
     }));
 }

package/dist/tools/edit-file.js

@@ -83,19 +83,19 @@ export function registerEditFileTool(server, options = {}) {
         guard: options.isInitialized,
         progressMessage: (args) => {
             const name = path.basename(args.path);
-            return `🛠 edit: ${name} (${args.edits.length} edits)`;
+            return `🛠 edit: ${name} [${args.edits.length} edits]`;
         },
         completionMessage: (args, result) => {
             const name = path.basename(args.path);
             if (result.isError)
-                return `🛠 edit: ${name} ➟ Failed`;
+                return `🛠 edit: ${name} • Failed`;
             const sc = result.structuredContent;
             if (!sc.ok)
-                return `🛠 edit: ${name} ➟ Failed`;
+                return `🛠 edit: ${name} • Failed`;
             if (sc.lineRange) {
-                return `🛠 edit: ${name} ➟ [${sc.lineRange[0]}-${sc.lineRange[1]}]`;
+                return `🛠 edit: ${name} • [${sc.lineRange[0]}-${sc.lineRange[1]}]`;
             }
-            return `🛠 edit: ${name} ➟ (${sc.appliedEdits ?? 0} edits)`;
+            return `🛠 edit: ${name} • [${sc.appliedEdits ?? 0} edits]`;
         },
     }));
 }

package/dist/tools/move-file.js

@@ -48,7 +48,7 @@ export function registerMoveFileTool(server, options = {}) {
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
-        progressMessage: (args) => `🛠 mv: ${path.basename(args.source)} ➟ ${path.basename(args.destination)}`,
+        progressMessage: (args) => `🛠 mv: ${path.basename(args.source)} • ${path.basename(args.destination)}`,
     });
     if (registerToolTaskIfAvailable(server, 'mv', MOVE_FILE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/dist/tools/read-multiple.js

@@ -123,7 +123,24 @@ export function registerReadMultipleFilesTool(server, options = {}) {
     };
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
-        progressMessage: (args) => `🕮 read_many: ${args.paths.length} files`,
+        progressMessage: (args) => {
+            const first = path.basename(args.paths[0] ?? '');
+            const extra = args.paths.length > 1 ? `, ${path.basename(args.paths[1] ?? '')}…` : '';
+            return `🕮 read_many: ${args.paths.length} files [${first}${extra}]`;
+        },
+        completionMessage: (_args, result) => {
+            if (result.isError)
+                return `🕮 read_many • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `🕮 read_many • failed`;
+            const total = sc.summary?.total ?? 0;
+            const succeeded = sc.summary?.succeeded ?? 0;
+            const failed = sc.summary?.failed ?? 0;
+            if (failed)
+                return `🕮 read_many: ${succeeded}/${total} read, ${failed} failed`;
+            return `🕮 read_many: ${total} files read`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'read_many', READ_MULTIPLE_FILES_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/dist/tools/read.js

@@ -90,6 +90,19 @@ export function registerReadFileTool(server, options = {}) {
             }
             return `🕮 read: ${name}`;
         },
+        completionMessage: (args, result) => {
+            const name = path.basename(args.path);
+            if (result.isError)
+                return `🕮 read: ${name} • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `🕮 read: ${name} • failed`;
+            if (sc.hasMoreLines)
+                return `🕮 read: ${name} • truncated [${sc.totalLines ?? '?'} lines]`;
+            if (sc.startLine !== undefined)
+                return `🕮 read: ${name} • lines ${sc.startLine}–${sc.endLine ?? '?'}`;
+            return `🕮 read: ${name} • ${sc.totalLines ?? '?'} lines`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'read', READ_FILE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/dist/tools/replace-in-files.js

@@ -231,18 +231,50 @@ export function registerSearchAndReplaceTool(server, options = {}) {
         timedSignal: {},
         ...(args.path ? { context: { path: args.path } } : {}),
         run: async (signal) => {
+            const dryLabel = args.dryRun ? ' [dry run]' : '';
+            const context = `"${args.searchPattern}" in ${args.filePattern}${dryLabel}`;
+            let progressCursor = 0;
             notifyProgress(extra, {
                 current: 0,
-                message: `🛠 search_and_replace: ${args.filePattern}`,
+                message: `🛠 search_and_replace: ${context}`,
             });
-            const result = await handleSearchAndReplace(args, signal, createProgressReporter(extra));
-            const sc = result.structuredContent;
-            const finalCurrent = (sc.processedFiles ?? 0) + 1;
-            notifyProgress(extra, {
-                current: finalCurrent,
-                message: `🛠 search_and_replace: ${args.filePattern} ➟ ${String(sc.filesChanged ?? 0)} files`,
-            });
-            return result;
+            const baseReporter = createProgressReporter(extra);
+            const progressWithMessage = ({ current, total, }) => {
+                if (current > progressCursor)
+                    progressCursor = current;
+                baseReporter({
+                    current,
+                    ...(total !== undefined ? { total } : {}),
+                    message: `🛠 search_and_replace: "${args.searchPattern}" — ${current} files processed`,
+                });
+            };
+            try {
+                const result = await handleSearchAndReplace(args, signal, progressWithMessage);
+                const sc = result.structuredContent;
+                const finalCurrent = Math.max((sc.processedFiles ?? 0) + 1, progressCursor + 1);
+                const matchWord = (sc.matches ?? 0) === 1 ? 'match' : 'matches';
+                const fileWord = (sc.filesChanged ?? 0) === 1 ? 'file' : 'files';
+                let endSuffix = `${sc.matches ?? 0} ${matchWord} in ${sc.filesChanged ?? 0} ${fileWord}`;
+                if (sc.failedFiles)
+                    endSuffix += `, ${sc.failedFiles} failed`;
+                if (sc.dryRun)
+                    endSuffix += ' [dry run]';
+                notifyProgress(extra, {
+                    current: finalCurrent,
+                    total: finalCurrent,
+                    message: `🛠 search_and_replace: ${context} • ${endSuffix}`,
+                });
+                return result;
+            }
+            catch (error) {
+                const finalCurrent = Math.max(progressCursor + 1, 1);
+                notifyProgress(extra, {
+                    current: finalCurrent,
+                    total: finalCurrent,
+                    message: `🛠 search_and_replace: ${context} • failed`,
+                });
+                throw error;
+            }
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
     });

package/dist/tools/search-content.js

@@ -202,29 +202,67 @@ export function registerSearchContentTool(server, options = {}) {
         context: { path: args.path ?? '.' },
         run: async (signal) => {
             const normalizedArgs = SearchContentInputSchema.parse(args);
+            const scope = normalizedArgs.filePattern;
+            const { pattern } = normalizedArgs;
+            let progressCursor = 0;
             notifyProgress(extra, {
                 current: 0,
-                message: `🔎︎ grep: ${normalizedArgs.pattern}`,
+                message: `🔎︎ grep: ${pattern} in ${scope}`,
             });
-            const result = await handleSearchContent(normalizedArgs, signal, options.resourceStore, createProgressReporter(extra));
-            const sc = result.structuredContent;
-            const count = sc.ok && sc.totalMatches ? sc.totalMatches : 0;
-            let suffix;
-            if (count === 0) {
-                suffix = 'No matches';
+            const baseReporter = createProgressReporter(extra);
+            const progressWithMessage = ({ current, total, }) => {
+                if (current > progressCursor)
+                    progressCursor = current;
+                const fileWord = current === 1 ? 'file' : 'files';
+                baseReporter({
+                    current,
+                    ...(total !== undefined ? { total } : {}),
+                    message: `🔎︎ grep: ${pattern} • ${current} ${fileWord} scanned`,
+                });
+            };
+            try {
+                const result = await handleSearchContent(normalizedArgs, signal, options.resourceStore, progressWithMessage);
+                const sc = result.structuredContent;
+                const count = sc.ok && sc.totalMatches ? sc.totalMatches : 0;
+                const filesMatched = sc.ok ? (sc.filesMatched ?? 0) : 0;
+                const stoppedReason = sc.ok ? sc.stoppedReason : undefined;
+                let suffix;
+                if (count === 0) {
+                    suffix = `No matches in ${scope}`;
+                }
+                else {
+                    const matchWord = count === 1 ? 'match' : 'matches';
+                    const fileInfo = filesMatched > 0
+                        ? ` in ${filesMatched} ${filesMatched === 1 ? 'file' : 'files'}`
+                        : '';
+                    suffix = `${count} ${matchWord}${fileInfo}`;
+                    if (stoppedReason === 'timeout') {
+                        suffix += ' [stopped — timeout]';
+                    }
+                    else if (stoppedReason === 'maxResults') {
+                        suffix += ' [truncated — max results]';
+                    }
+                    else if (stoppedReason === 'maxFiles') {
+                        suffix += ' [truncated — max files]';
+                    }
+                }
+                const finalCurrent = Math.max((sc.filesScanned ?? 0) + 1, progressCursor + 1);
+                notifyProgress(extra, {
+                    current: finalCurrent,
+                    total: finalCurrent,
+                    message: `🔎︎ grep: ${pattern} • ${suffix}`,
+                });
+                return result;
             }
-            else if (count === 1) {
-                suffix = '1 match';
+            catch (error) {
+                const finalCurrent = Math.max(progressCursor + 1, 1);
+                notifyProgress(extra, {
+                    current: finalCurrent,
+                    total: finalCurrent,
+                    message: `🔎︎ grep: ${pattern} in ${scope} • failed`,
+                });
+                throw error;
             }
-            else {
-                suffix = `${count} matches`;
-            }
-            const finalCurrent = (sc.filesScanned ?? 0) + 1;
-            notifyProgress(extra, {
-                current: finalCurrent,
-                message: `🔎︎ grep: ${normalizedArgs.pattern} ➟ ${suffix}`,
-            });
-            return result;
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path ?? '.'),
     });

package/dist/tools/search-files.js

@@ -89,19 +89,62 @@ export function registerSearchFilesTool(server, options = {}) {
         timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
         context: { path: args.path ?? '.' },
         run: async (signal) => {
+            const scope = args.path ?? '.';
+            const { pattern } = args;
+            let progressCursor = 0;
             notifyProgress(extra, {
                 current: 0,
-                message: `🔎︎ find: ${args.pattern}`,
+                message: `🔎︎ find: ${pattern} in ${scope}`,
             });
-            const result = await handleSearchFiles(args, signal, createProgressReporter(extra));
-            const sc = result.structuredContent;
-            const suffix = sc.ok && sc.totalMatches ? String(sc.totalMatches) : 'No matches';
-            const finalCurrent = (sc.filesScanned ?? 0) + 1;
-            notifyProgress(extra, {
-                current: finalCurrent,
-                message: `🔎︎ find: ${args.pattern} ➟ ${suffix}`,
-            });
-            return result;
+            const baseReporter = createProgressReporter(extra);
+            const progressWithMessage = ({ current, total, }) => {
+                if (current > progressCursor)
+                    progressCursor = current;
+                const fileWord = current === 1 ? 'file' : 'files';
+                baseReporter({
+                    current,
+                    ...(total !== undefined ? { total } : {}),
+                    message: `🔎︎ find: ${pattern} — ${current} ${fileWord} scanned`,
+                });
+            };
+            try {
+                const result = await handleSearchFiles(args, signal, progressWithMessage);
+                const sc = result.structuredContent;
+                const count = sc.ok ? (sc.totalMatches ?? 0) : 0;
+                const stoppedReason = sc.ok ? sc.stoppedReason : undefined;
+                let suffix;
+                if (count === 0) {
+                    suffix = `No matches in ${scope}`;
+                }
+                else {
+                    suffix = `${count} ${count === 1 ? 'match' : 'matches'}`;
+                    if (stoppedReason === 'timeout') {
+                        suffix += ' [stopped — timeout]';
+                    }
+                    else if (stoppedReason === 'maxResults') {
+                        suffix += ' [truncated — max results]';
+                    }
+                    else if (stoppedReason === 'maxFiles') {
+                        suffix += ' [truncated — max files]';
+                    }
+                }
+                const finalCurrent = Math.max((sc.filesScanned ?? 0) + 1, progressCursor + 1);
+                notifyProgress(extra, {
+                    current: finalCurrent,
+                    total: finalCurrent,
+                    message: `🔎︎ find: ${pattern} • ${suffix}`,
+                });
+                return result;
+            }
+            catch (error) {
+                const finalCurrent = Math.max(progressCursor + 1, 1);
+                notifyProgress(extra, {
+                    current: finalCurrent,
+                    total: finalCurrent,
+                    message: `🔎︎ find: ${pattern} in ${scope} • failed`,
+                });
+                throw error;
+            }
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_INVALID_PATTERN, args.path),
     });

package/dist/tools/shared.d.ts

@@ -19,6 +19,8 @@ export declare const IDEMPOTENT_WRITE_TOOL_ANNOTATIONS: {
     readonly idempotentHint: true;
     readonly openWorldHint: false;
 };
+export declare function shouldStripStructuredOutput(): boolean;
+export declare function maybeStripStructuredContentFromResult<T extends object>(result: T): T;
 type ResourceEntry = ReturnType<ResourceStore['putText']>;
 export declare function maybeExternalizeTextContent(resourceStore: ResourceStore | undefined, content: string, params: {
     name: string;

package/dist/tools/shared.js

@@ -5,6 +5,7 @@ import { getAllowedDirectories } from '../lib/path-validation.js';
 const MAX_INLINE_CONTENT_CHARS = 20_000;
 const MAX_INLINE_PREVIEW_CHARS = 4_000;
 const PROGRESS_RATE_LIMIT_MS = 50;
+const TRUE_ENV_VALUES = new Set(['1', 'true', 'yes']);
 export const READ_ONLY_TOOL_ANNOTATIONS = {
     readOnlyHint: true,
     idempotentHint: true,
@@ -20,6 +21,30 @@ export const IDEMPOTENT_WRITE_TOOL_ANNOTATIONS = {
     idempotentHint: true,
     openWorldHint: false,
 };
+export function shouldStripStructuredOutput() {
+    const value = process.env['FS_CONTEXT_STRIP_STRUCTURED'];
+    if (value === undefined)
+        return false;
+    return TRUE_ENV_VALUES.has(value.trim().toLowerCase());
+}
+export function maybeStripStructuredContentFromResult(result) {
+    if (!shouldStripStructuredOutput())
+        return result;
+    if (!Object.hasOwn(result, 'structuredContent'))
+        return result;
+    const rest = { ...result };
+    delete rest['structuredContent'];
+    return rest;
+}
+function maybeStripOutputSchema(tool) {
+    if (!shouldStripStructuredOutput())
+        return tool;
+    if (!Object.hasOwn(tool, 'outputSchema'))
+        return tool;
+    const mutable = { ...tool };
+    delete mutable['outputSchema'];
+    return mutable;
+}
 function buildTextPreview(text) {
     if (text.length <= MAX_INLINE_PREVIEW_CHARS)
         return text;
@@ -71,13 +96,14 @@ function canSendProgress(extra) {
         extra.sendNotification !== undefined);
 }
 export function withDefaultIcons(tool, iconInfo) {
-    if (!iconInfo)
-        return tool;
+    if (!iconInfo) {
+        return maybeStripOutputSchema(tool);
+    }
     const existingIcons = tool.icons;
     if (existingIcons && existingIcons.length > 0) {
-        return tool;
+        return maybeStripOutputSchema(tool);
     }
-    return {
+    const withIcons = {
         ...tool,
         icons: [
             {
@@ -86,6 +112,7 @@ export function withDefaultIcons(tool, iconInfo) {
             },
         ],
     };
+    return maybeStripOutputSchema(withIcons);
 }
 export function buildFileInfoPayload(info) {
     return {
@@ -247,7 +274,7 @@ export function wrapToolHandler(handler, options) {
     return async (args, extra) => {
         const resolvedExtra = extra ?? {};
         if (options.guard && !options.guard()) {
-            return buildNotInitializedResult();
+            return maybeStripStructuredContentFromResult(buildNotInitializedResult());
         }
         if (options.progressMessage) {
             const message = options.progressMessage(args);
@@ -255,9 +282,11 @@ export function wrapToolHandler(handler, options) {
             const completionFn = completionMessage
                 ? (result) => completionMessage(args, result)
                 : undefined;
-            return withProgress(message, resolvedExtra, () => handler(args, resolvedExtra), completionFn);
+            const result = await withProgress(message, resolvedExtra, () => handler(args, resolvedExtra), completionFn);
+            return maybeStripStructuredContentFromResult(result);
         }
-        return handler(args, resolvedExtra);
+        const result = await handler(args, resolvedExtra);
+        return maybeStripStructuredContentFromResult(result);
     };
 }
 export function resolvePathOrRoot(pathValue) {

package/dist/tools/stat-many.js

@@ -1,3 +1,4 @@
+import * as path from 'node:path';
 import { formatBytes, joinLines } from '../config.js';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
@@ -74,7 +75,24 @@ export function registerGetMultipleFileInfoTool(server, options = {}) {
     };
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
-        progressMessage: (args) => `🕮 stat_many: ${args.paths.length} paths`,
+        progressMessage: (args) => {
+            const first = path.basename(args.paths[0] ?? '');
+            const extra = args.paths.length > 1 ? `, ${path.basename(args.paths[1] ?? '')}…` : '';
+            return `🕮 stat_many: ${args.paths.length} paths [${first}${extra}]`;
+        },
+        completionMessage: (_args, result) => {
+            if (result.isError)
+                return `🕮 stat_many • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `🕮 stat_many • failed`;
+            const total = sc.summary?.total ?? 0;
+            const succeeded = sc.summary?.succeeded ?? 0;
+            const failed = sc.summary?.failed ?? 0;
+            if (failed)
+                return `🕮 stat_many: ${succeeded}/${total} OK, ${failed} failed`;
+            return `🕮 stat_many: ${total} OK`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'stat_many', GET_MULTIPLE_FILE_INFO_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/dist/tools/stat.js

@@ -48,5 +48,14 @@ export function registerGetFileInfoTool(server, options = {}) {
     server.registerTool('stat', withDefaultIcons({ ...GET_FILE_INFO_TOOL }, options.iconInfo), wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🕮 stat: ${path.basename(args.path)}`,
+        completionMessage: (args, result) => {
+            const name = path.basename(args.path);
+            if (result.isError)
+                return `🕮 stat: ${name} • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok || !sc.info)
+                return `🕮 stat: ${name} • failed`;
+            return `🕮 stat: ${sc.info.name} [${sc.info.type}, ${formatBytes(sc.info.size)}]`;
+        },
     }));
 }

package/dist/tools/task-support.js

@@ -1,7 +1,7 @@
 import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { isRecord } from '../lib/type-guards.js';
-import { buildToolErrorResponse, withDefaultIcons } from './shared.js';
+import { buildToolErrorResponse, maybeStripStructuredContentFromResult, withDefaultIcons, } from './shared.js';
 function isExperimentalTaskRegistration(value) {
     if (!value || typeof value !== 'object')
         return false;
@@ -191,13 +191,13 @@ async function tryStoreTaskResult(taskStore, taskId, status, result) {
 }
 async function runTaskInBackground(run, args, extra, taskStore, taskId) {
     try {
-        const result = await run(args, extra);
+        const result = maybeStripStructuredContentFromResult(await run(args, extra));
         const status = isErrorResult(result) ? 'failed' : 'completed';
         await tryStoreTaskResult(taskStore, taskId, status, result);
         await notifyTaskStatusIfPossible(extra, taskStore, taskId);
     }
     catch (error) {
-        const fallback = buildToolErrorResponse(error, ErrorCode.E_UNKNOWN);
+        const fallback = maybeStripStructuredContentFromResult(buildToolErrorResponse(error, ErrorCode.E_UNKNOWN));
         try {
             await tryStoreTaskResult(taskStore, taskId, 'failed', fallback);
             await notifyTaskStatusIfPossible(extra, taskStore, taskId);

package/dist/tools/write-file.js

@@ -36,7 +36,16 @@ export function registerWriteFileTool(server, options = {}) {
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
-        progressMessage: (args) => `🛠 write: ${path.basename(args.path)}`,
+        progressMessage: (args) => `🛠 write: ${path.basename(args.path)} [${args.content.length} chars]`,
+        completionMessage: (args, result) => {
+            const name = path.basename(args.path);
+            if (result.isError)
+                return `🛠 write: ${name} • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `🛠 write: ${name} • failed`;
+            return `🛠 write: ${name} • ${sc.bytesWritten ?? 0} bytes`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'write', WRITE_FILE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "MCP Server that enables LLMs to interact with the local filesystem.",
   "type": "module",
@@ -31,12 +31,14 @@
     "start": "node dist/index.js",
     "format": "prettier --write .",
     "type-check": "node scripts/tasks.mjs type-check",
+    "type-check:src": "node node_modules/typescript/bin/tsc -p tsconfig.json --noEmit",
+    "type-check:tests": "node node_modules/typescript/bin/tsc -p tsconfig.test.json --noEmit",
     "type-check:diagnostics": "tsc --noEmit --extendedDiagnostics",
     "type-check:trace": "node -e \"require('fs').rmSync('.ts-trace',{recursive:true,force:true})\" && tsc --noEmit --generateTrace .ts-trace",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "node scripts/tasks.mjs test",
-    "test:fast": "node --test --import tsx/esm src/__tests__/**/*.test.ts",
+    "test:fast": "node --test --import tsx/esm src/__tests__/**/*.test.ts node-tests/**/*.test.ts",
     "test:coverage": "node scripts/tasks.mjs test --coverage",
     "knip": "knip",
     "knip:fix": "knip --fix",