@j0hanz/filesystem-mcp 1.2.0 → 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/config.d.ts

@@ -102,6 +102,7 @@ export declare const ErrorCode: {
     readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
     readonly E_TOO_LARGE: "E_TOO_LARGE";
     readonly E_TIMEOUT: "E_TIMEOUT";
+    readonly E_CANCELLED: "E_CANCELLED";
     readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
     readonly E_INVALID_INPUT: "E_INVALID_INPUT";
     readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";

package/dist/config.js

@@ -5,6 +5,7 @@ export const ErrorCode = {
     E_NOT_DIRECTORY: 'E_NOT_DIRECTORY',
     E_TOO_LARGE: 'E_TOO_LARGE',
     E_TIMEOUT: 'E_TIMEOUT',
+    E_CANCELLED: 'E_CANCELLED',
     E_INVALID_PATTERN: 'E_INVALID_PATTERN',
     E_INVALID_INPUT: 'E_INVALID_INPUT',
     E_PERMISSION_DENIED: 'E_PERMISSION_DENIED',

package/dist/lib/errors.js

@@ -146,8 +146,6 @@ function isTimeoutErrorSingle(error) {
         return false;
     if (error.name === 'TimeoutError')
         return true;
-    if (isAbortErrorSingle(error))
-        return true;
     const code = getNodeErrorCodeLabel(error);
     if (code === 'ETIMEDOUT')
         return true;
@@ -184,6 +182,7 @@ const ERROR_SUGGESTIONS = {
     [ErrorCode.E_NOT_DIRECTORY]: 'The path points to a file, not a directory. Use read to read file contents.',
     [ErrorCode.E_TOO_LARGE]: 'The file exceeds the size limit. Use head to read a partial preview, or narrow the scope of what you read.',
     [ErrorCode.E_TIMEOUT]: 'The operation timed out. Try a smaller scope (narrower path), fewer results (maxResults), or search fewer files.',
+    [ErrorCode.E_CANCELLED]: 'The operation was cancelled. This is not an error — no retry is needed unless you want to re-run the operation.',
     [ErrorCode.E_INVALID_PATTERN]: 'The glob or regex pattern is invalid. Check syntax and escape special characters.',
     [ErrorCode.E_INVALID_INPUT]: 'One or more input parameters are invalid. Check the tool documentation for correct usage.',
     [ErrorCode.E_PERMISSION_DENIED]: 'Permission denied by the operating system. Check file permissions.',
@@ -220,6 +219,9 @@ function classifyMessageError(error) {
     return undefined;
 }
 function classifyError(error) {
+    if (isAbortError(error)) {
+        return ErrorCode.E_CANCELLED;
+    }
     if (isTimeoutLikeError(error)) {
         return ErrorCode.E_TIMEOUT;
     }

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/schemas.d.ts

@@ -21,6 +21,7 @@ export declare const ToolErrorResponseSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -112,6 +113,7 @@ export declare const ListAllowedDirectoriesOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -159,6 +161,7 @@ export declare const ListDirectoryOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -182,6 +185,7 @@ export declare const SearchFilesOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -220,6 +224,7 @@ export declare const SearchContentOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -271,6 +276,7 @@ export declare const TreeOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -307,6 +313,7 @@ export declare const ReadFileOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -357,6 +364,7 @@ export declare const ReadMultipleFilesOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -397,6 +405,7 @@ export declare const GetFileInfoOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -446,6 +455,7 @@ export declare const GetMultipleFileInfoOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -471,6 +481,7 @@ export declare const CreateDirectoryOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -498,6 +509,7 @@ export declare const WriteFileOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -531,6 +543,7 @@ export declare const EditFileOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -558,6 +571,7 @@ export declare const MoveFileOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -585,6 +599,7 @@ export declare const DeleteFileOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -613,6 +628,7 @@ export declare const CalculateHashOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -645,6 +661,7 @@ export declare const DiffFilesOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -675,6 +692,7 @@ export declare const ApplyPatchOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
@@ -718,6 +736,7 @@ export declare const SearchAndReplaceOutputSchema: z.ZodObject<{
             readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
             readonly E_TOO_LARGE: "E_TOO_LARGE";
             readonly E_TIMEOUT: "E_TIMEOUT";
+            readonly E_CANCELLED: "E_CANCELLED";
             readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
             readonly E_INVALID_INPUT: "E_INVALID_INPUT";
             readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";

package/dist/server.js

@@ -300,24 +300,6 @@ export async function createServer(options = {}) {
     registerGetHelpPrompt(server, serverInstructions, localIcon);
     registerResultResources(server, resourceStore, localIcon);
     registerCompletions(server);
-    {
-        const typedServer = server;
-        const origReg = typedServer.registerTool.bind(server);
-        typedServer.registerTool = (...regArgs) => {
-            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

@@ -5,7 +5,7 @@ import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
-import { ApplyPatchInputSchema, } from '../schemas.js';
+import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const APPLY_PATCH_TOOL = {
@@ -14,6 +14,7 @@ const APPLY_PATCH_TOOL = {
         'Generate the patch with `diff_files`, then validate with `dryRun: true` before writing. ' +
         'On failure, regenerate a fresh patch via `diff_files` against the current file content and retry.',
     inputSchema: ApplyPatchInputSchema,
+    outputSchema: ApplyPatchOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 function assertPatchTargetSizeWithinLimit(filePath, size, maxFileSize) {
@@ -72,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

@@ -8,7 +8,7 @@ import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations
 import { globEntries } from '../lib/file-operations/glob-engine.js';
 import { assertNotAborted, withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
-import { CalculateHashInputSchema, } from '../schemas.js';
+import { CalculateHashInputSchema, CalculateHashOutputSchema, } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const WINDOWS_PATH_SEPARATOR = /\\/gu;
@@ -16,6 +16,7 @@ const CALCULATE_HASH_TOOL = {
     title: 'Calculate Hash',
     description: 'Calculate SHA-256 hash of a file or directory.',
     inputSchema: CalculateHashInputSchema,
+    outputSchema: CalculateHashOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 async function hashFile(filePath, encoding, signal) {
@@ -152,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

@@ -3,13 +3,14 @@ import * as path from 'node:path';
 import { ErrorCode } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/path-validation.js';
-import { CreateDirectoryInputSchema, } from '../schemas.js';
+import { CreateDirectoryInputSchema, CreateDirectoryOutputSchema, } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, IDEMPOTENT_WRITE_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const CREATE_DIRECTORY_TOOL = {
     title: 'Create Directory',
     description: 'Create a new directory at the specified path (recursive)',
     inputSchema: CreateDirectoryInputSchema,
+    outputSchema: CreateDirectoryOutputSchema,
     annotations: IDEMPOTENT_WRITE_TOOL_ANNOTATIONS,
 };
 async function handleCreateDirectory(args, signal) {
@@ -31,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/delete-file.js

@@ -3,13 +3,14 @@ import * as path from 'node:path';
 import { ErrorCode, isNodeError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/path-validation.js';
-import { DeleteFileInputSchema, } from '../schemas.js';
+import { DeleteFileInputSchema, DeleteFileOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const DELETE_FILE_TOOL = {
     title: 'Delete File',
     description: 'Delete a file or directory.',
     inputSchema: DeleteFileInputSchema,
+    outputSchema: DeleteFileOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 async function handleDeleteFile(args, signal) {

package/dist/tools/diff-files.js

@@ -5,7 +5,7 @@ import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
-import { DiffFilesInputSchema, } from '../schemas.js';
+import { DiffFilesInputSchema, DiffFilesOutputSchema } from '../schemas.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 const DIFF_FILES_TOOL = {
     title: 'Diff Files',
@@ -13,6 +13,7 @@ const DIFF_FILES_TOOL = {
         'Output feeds directly into `apply_patch`. ' +
         'Check `isIdentical` in the response — if true, the files are already in sync and no patch is needed.',
     inputSchema: DiffFilesInputSchema,
+    outputSchema: DiffFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 function assertDiffFileSizeWithinLimit(filePath, size, maxFileSize) {
@@ -86,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

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import { ErrorCode } from '../lib/errors.js';
 import { atomicWriteFile } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
-import { EditFileInputSchema } from '../schemas.js';
+import { EditFileInputSchema, EditFileOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
 const EDIT_FILE_TOOL = {
     title: 'Edit File',
@@ -12,6 +12,7 @@ const EDIT_FILE_TOOL = {
         '`oldText` must match exactly — include 3–5 lines of surrounding context to uniquely target the location. ' +
         'Use `dryRun: true` to validate edits before writing.',
     inputSchema: EditFileInputSchema,
+    outputSchema: EditFileOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 function applyEdits(content, edits) {
@@ -82,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/list-directory.js

@@ -3,7 +3,7 @@ import { formatOperationSummary, joinLines } from '../config.js';
 import { DEFAULT_EXCLUDE_PATTERNS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { listDirectory } from '../lib/file-operations/list-directory.js';
-import { ListDirectoryInputSchema, } from '../schemas.js';
+import { ListDirectoryInputSchema, ListDirectoryOutputSchema, } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
 const LIST_DIRECTORY_TOOL = {
     title: 'List Directory',
@@ -13,6 +13,7 @@ const LIST_DIRECTORY_TOOL = {
         'Use includeIgnored=true to include ignored directories like node_modules. ' +
         'For recursive searches, use find instead.',
     inputSchema: ListDirectoryInputSchema,
+    outputSchema: ListDirectoryOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 function buildListTextResult(result) {

package/dist/tools/move-file.js

@@ -3,13 +3,14 @@ import * as path from 'node:path';
 import { ErrorCode, isNodeError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath, validatePathForWrite, } from '../lib/path-validation.js';
-import { MoveFileInputSchema } from '../schemas.js';
+import { MoveFileInputSchema, MoveFileOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const MOVE_FILE_TOOL = {
     title: 'Move File',
     description: 'Move or rename a file or directory.',
     inputSchema: MoveFileInputSchema,
+    outputSchema: MoveFileOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 async function handleMoveFile(args, signal) {
@@ -47,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

@@ -2,7 +2,7 @@ import * as path from 'node:path';
 import { DEFAULT_READ_MANY_MAX_TOTAL_SIZE, DEFAULT_SEARCH_TIMEOUT_MS, } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { readMultipleFiles } from '../lib/file-operations/read-multiple-files.js';
-import { ReadMultipleFilesInputSchema, } from '../schemas.js';
+import { ReadMultipleFilesInputSchema, ReadMultipleFilesOutputSchema, } from '../schemas.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const READ_MULTIPLE_FILES_TOOL = {
@@ -11,6 +11,7 @@ const READ_MULTIPLE_FILES_TOOL = {
         'Returns contents and metadata for each file. ' +
         'For single file, use read for simpler output.',
     inputSchema: ReadMultipleFilesInputSchema,
+    outputSchema: ReadMultipleFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 async function handleReadMultipleFiles(args, signal, resourceStore) {
@@ -122,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

@@ -2,7 +2,7 @@ import * as path from 'node:path';
 import { DEFAULT_SEARCH_TIMEOUT_MS, MAX_TEXT_FILE_SIZE, } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { readFile } from '../lib/fs-helpers.js';
-import { ReadFileInputSchema } from '../schemas.js';
+import { ReadFileInputSchema, ReadFileOutputSchema } from '../schemas.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const READ_FILE_TOOL = {
@@ -11,6 +11,7 @@ const READ_FILE_TOOL = {
         'Use head parameter to preview the first N lines of large files. ' +
         'For multiple files, use read_many for efficiency.',
     inputSchema: ReadFileInputSchema,
+    outputSchema: ReadFileOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 async function handleReadFile(args, signal, resourceStore) {
@@ -89,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

@@ -7,7 +7,7 @@ import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.j
 import { globEntries } from '../lib/file-operations/glob-engine.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath, validatePathForWrite, } from '../lib/path-validation.js';
-import { SearchAndReplaceInputSchema, } from '../schemas.js';
+import { SearchAndReplaceInputSchema, SearchAndReplaceOutputSchema, } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, createProgressReporter, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, notifyProgress, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const SEARCH_AND_REPLACE_TOOL = {
@@ -18,6 +18,7 @@ const SEARCH_AND_REPLACE_TOOL = {
         'Always run with `dryRun: true` first to verify matches before writing. ' +
         'Literal mode (default) matches exact text; `isRegex: true` enables RE2 regex with capture groups ($1, $2).',
     inputSchema: SearchAndReplaceInputSchema,
+    outputSchema: SearchAndReplaceOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 const MAX_FAILURES = 20;
@@ -230,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/roots.js

@@ -1,7 +1,7 @@
 import { joinLines } from '../config.js';
 import { ErrorCode } from '../lib/errors.js';
 import { getAllowedDirectories } from '../lib/path-validation.js';
-import { ListAllowedDirectoriesInputSchema, } from '../schemas.js';
+import { ListAllowedDirectoriesInputSchema, ListAllowedDirectoriesOutputSchema, } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 const LIST_ALLOWED_DIRECTORIES_TOOL = {
     title: 'Workspace Roots',
@@ -9,6 +9,7 @@ const LIST_ALLOWED_DIRECTORIES_TOOL = {
         'Call this first to see available directories. ' +
         'All other tools only work within these directories.',
     inputSchema: ListAllowedDirectoriesInputSchema,
+    outputSchema: ListAllowedDirectoriesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 function buildTextRoots(dirs) {

package/dist/tools/search-content.js

@@ -4,7 +4,7 @@ import { formatOperationSummary, joinLines } from '../config.js';
 import { DEFAULT_EXCLUDE_PATTERNS } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
 import { searchContent } from '../lib/file-operations/search-content.js';
-import { SearchContentInputSchema, } from '../schemas.js';
+import { SearchContentInputSchema, SearchContentOutputSchema, } from '../schemas.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const MAX_INLINE_MATCHES = 50;
@@ -16,6 +16,7 @@ const SEARCH_CONTENT_TOOL = {
         'Use `filePattern` to scope by file type (e.g. `**/*.ts`) and avoid noisy results. ' +
         'Use includeHidden=true to include hidden files and directories.',
     inputSchema: SearchContentInputSchema,
+    outputSchema: SearchContentOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 function assertValidRegexPattern(pattern) {
@@ -201,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

@@ -3,7 +3,7 @@ import { formatOperationSummary, joinLines } from '../config.js';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_TIMEOUT_MS, } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { searchFiles } from '../lib/file-operations/search-files.js';
-import { SearchFilesInputSchema, } from '../schemas.js';
+import { SearchFilesInputSchema, SearchFilesOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const SEARCH_FILES_TOOL = {
@@ -13,6 +13,7 @@ const SEARCH_FILES_TOOL = {
         'For text search inside files, use grep. ' +
         'To bulk-edit the matched files, pass the same glob pattern to search_and_replace.',
     inputSchema: SearchFilesInputSchema,
+    outputSchema: SearchFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 async function handleSearchFiles(args, signal, onProgress) {
@@ -88,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,14 +1,16 @@
+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';
 import { getMultipleFileInfo } from '../lib/file-operations/file-info.js';
-import { GetMultipleFileInfoInputSchema, } from '../schemas.js';
+import { GetMultipleFileInfoInputSchema, GetMultipleFileInfoOutputSchema, } from '../schemas.js';
 import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const GET_MULTIPLE_FILE_INFO_TOOL = {
     title: 'Get Multiple File Info',
     description: 'Get metadata for multiple files or directories in one request.',
     inputSchema: GetMultipleFileInfoInputSchema,
+    outputSchema: GetMultipleFileInfoOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 function formatFileInfoDetail(info) {
@@ -73,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

@@ -3,12 +3,13 @@ import { formatBytes, joinLines } from '../config.js';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { getFileInfo } from '../lib/file-operations/file-info.js';
-import { GetFileInfoInputSchema, } from '../schemas.js';
+import { GetFileInfoInputSchema, GetFileInfoOutputSchema } from '../schemas.js';
 import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 const GET_FILE_INFO_TOOL = {
     title: 'Get File Info',
     description: 'Get metadata (size, modified time, permissions, mime type) for a file or directory.',
     inputSchema: GetFileInfoInputSchema,
+    outputSchema: GetFileInfoOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 function formatFileInfoDetails(info) {
@@ -47,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/tree.js

@@ -2,7 +2,7 @@ import * as path from 'node:path';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { formatTreeAscii, treeDirectory } from '../lib/file-operations/tree.js';
-import { TreeInputSchema } from '../schemas.js';
+import { TreeInputSchema, TreeOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const TREE_TOOL = {
@@ -11,6 +11,7 @@ const TREE_TOOL = {
         'Returns an ASCII tree for quick scanning and a structured JSON tree for programmatic use. ' +
         'Note: maxDepth=0 returns only the root node with empty children array.',
     inputSchema: TreeInputSchema,
+    outputSchema: TreeOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 async function handleTree(args, signal) {

package/dist/tools/write-file.js

@@ -3,13 +3,14 @@ import * as path from 'node:path';
 import { ErrorCode } from '../lib/errors.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/path-validation.js';
-import { WriteFileInputSchema, } from '../schemas.js';
+import { WriteFileInputSchema, WriteFileOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const WRITE_FILE_TOOL = {
     title: 'Write File',
     description: 'Write content to a file. Creates the file if it does not exist.',
     inputSchema: WriteFileInputSchema,
+    outputSchema: WriteFileOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 async function handleWriteFile(args, signal) {
@@ -35,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.0",
+  "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",