@j0hanz/filesystem-mcp 1.2.2 → 1.2.3

package/dist/tools/search-content.js

@@ -5,7 +5,7 @@ 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, SearchContentOutputSchema, } from '../schemas.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const MAX_INLINE_MATCHES = 50;
 const SEARCH_CONTENT_TOOL = {
@@ -69,16 +69,14 @@ function formatSearchMatchLine(match) {
 }
 function buildStructuredSearchResult(result, normalizedMatches, options) {
     const { summary } = result;
-    const matches = [];
-    for (const match of normalizedMatches) {
-        matches.push(buildSearchMatchPayload(match));
-    }
+    const matches = normalizedMatches.map((match) => buildSearchMatchPayload(match));
     return {
         ok: true,
         patternType: options.patternType,
         caseSensitive: options.caseSensitive,
         matches,
         totalMatches: summary.matches,
+        filesScanned: summary.filesScanned,
         ...(summary.truncated ? { truncated: summary.truncated } : {}),
         ...(summary.filesMatched ? { filesMatched: summary.filesMatched } : {}),
         ...(summary.skippedTooLarge
@@ -163,10 +161,7 @@ async function handleSearchContent(args, signal, resourceStore, onProgress) {
         return buildToolResponse(buildSearchTextResult(result, normalizedMatches), structuredFull);
     }
     const previewMatches = normalizedMatches.slice(0, MAX_INLINE_MATCHES);
-    const previewPayload = [];
-    for (const match of previewMatches) {
-        previewPayload.push(buildSearchMatchPayload(match));
-    }
+    const previewPayload = previewMatches.map((match) => buildSearchMatchPayload(match));
     const previewStructured = {
         ...structuredFull,
         matches: previewPayload,
@@ -201,9 +196,8 @@ export function registerSearchContentTool(server, options = {}) {
         extra,
         context: { path: args.path ?? '.' },
         run: async (signal) => {
-            const normalizedArgs = SearchContentInputSchema.parse(args);
-            const scope = normalizedArgs.filePattern;
-            const { pattern } = normalizedArgs;
+            const scope = args.filePattern;
+            const { pattern } = args;
             let progressCursor = 0;
             notifyProgress(extra, {
                 current: 0,
@@ -217,11 +211,11 @@ export function registerSearchContentTool(server, options = {}) {
                 baseReporter({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🔎︎ grep: ${pattern} • ${current} ${fileWord} scanned`,
+                    message: `🔎︎ grep: ${pattern} — ${current} ${fileWord} scanned`,
                 });
             };
             try {
-                const result = await handleSearchContent(normalizedArgs, signal, options.resourceStore, progressWithMessage);
+                const result = await handleSearchContent(args, 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;
@@ -267,7 +261,8 @@ export function registerSearchContentTool(server, options = {}) {
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path ?? '.'),
     });
     const { isInitialized } = options;
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(SearchContentInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: isInitialized,
     });
     if (registerToolTaskIfAvailable(server, 'grep', SEARCH_CONTENT_TOOL, wrappedHandler, options.iconInfo, isInitialized))

package/dist/tools/search-files.js

@@ -4,7 +4,7 @@ import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_TIMEOUT_MS, } from '../lib/con
 import { ErrorCode } from '../lib/errors.js';
 import { searchFiles } from '../lib/file-operations/search-files.js';
 import { SearchFilesInputSchema, SearchFilesOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const SEARCH_FILES_TOOL = {
     title: 'Find Files',
@@ -43,6 +43,7 @@ async function handleSearchFiles(args, signal, onProgress) {
         pattern: args.pattern,
         results: relativeResults,
         totalMatches: result.summary.matched,
+        filesScanned: result.summary.filesScanned,
         ...(result.summary.truncated
             ? { truncated: result.summary.truncated }
             : {}),
@@ -89,12 +90,14 @@ export function registerSearchFilesTool(server, options = {}) {
         timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
         context: { path: args.path ?? '.' },
         run: async (signal) => {
-            const scope = args.path ?? '.';
+            const rawScopeLabel = args.path ? path.basename(args.path) : '.';
+            const scopeLabel = rawScopeLabel || '.';
             const { pattern } = args;
+            const context = `${pattern} in ${scopeLabel}`;
             let progressCursor = 0;
             notifyProgress(extra, {
                 current: 0,
-                message: `🔎︎ find: ${pattern} in ${scope}`,
+                message: `🔎︎ find: ${context}`,
             });
             const baseReporter = createProgressReporter(extra);
             const progressWithMessage = ({ current, total, }) => {
@@ -104,7 +107,7 @@ export function registerSearchFilesTool(server, options = {}) {
                 baseReporter({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🔎︎ find: ${pattern} — ${current} ${fileWord} scanned`,
+                    message: `🔎︎ find: ${pattern} [${current} ${fileWord} scanned]`,
                 });
             };
             try {
@@ -114,7 +117,7 @@ export function registerSearchFilesTool(server, options = {}) {
                 const stoppedReason = sc.ok ? sc.stoppedReason : undefined;
                 let suffix;
                 if (count === 0) {
-                    suffix = `No matches in ${scope}`;
+                    suffix = `No matches in ${scopeLabel}`;
                 }
                 else {
                     suffix = `${count} ${count === 1 ? 'match' : 'matches'}`;
@@ -132,7 +135,7 @@ export function registerSearchFilesTool(server, options = {}) {
                 notifyProgress(extra, {
                     current: finalCurrent,
                     total: finalCurrent,
-                    message: `🔎︎ find: ${pattern} • ${suffix}`,
+                    message: `🔎︎ find: ${context} • ${suffix}`,
                 });
                 return result;
             }
@@ -141,15 +144,16 @@ export function registerSearchFilesTool(server, options = {}) {
                 notifyProgress(extra, {
                     current: finalCurrent,
                     total: finalCurrent,
-                    message: `🔎︎ find: ${pattern} in ${scope} • failed`,
+                    message: `🔎︎ find: ${context} • failed`,
                 });
                 throw error;
             }
         },
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_INVALID_PATTERN, args.path),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
     });
     const { isInitialized } = options;
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(SearchFilesInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: isInitialized,
     });
     if (registerToolTaskIfAvailable(server, 'find', SEARCH_FILES_TOOL, wrappedHandler, options.iconInfo, isInitialized))

package/dist/tools/shared.d.ts

@@ -1,5 +1,5 @@
 import type { ContentBlock, Icon, ProgressNotificationParams } from '@modelcontextprotocol/sdk/types.js';
-import type { z } from 'zod';
+import { z } from 'zod';
 import type { FileInfo } from '../config.js';
 import { ErrorCode } from '../lib/errors.js';
 import type { ResourceStore } from '../lib/resource-store.js';
@@ -47,6 +47,8 @@ interface ToolErrorResponse extends Record<string, unknown> {
     isError: true;
 }
 export type ToolResult<T> = ToolResponse<T> | ToolErrorResponse;
+export declare function parseToolArgs<Schema extends z.ZodType>(schema: Schema, args: unknown): z.infer<Schema>;
+export declare function withValidatedArgs<Args, Result>(schema: z.ZodType<Args>, handler: (args: Args, extra: ToolExtra) => Promise<ToolResult<Result>>): (args: Args, extra: ToolExtra) => Promise<ToolResult<Result>>;
 type ProgressToken = string | number;
 export interface ToolExtra {
     signal?: AbortSignal;

package/dist/tools/shared.js

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { createDetailedError, ErrorCode, formatDetailedError, getSuggestion, McpError, } from '../lib/errors.js';
 import { createTimedAbortSignal } from '../lib/fs-helpers.js';
 import { withToolDiagnostics } from '../lib/observability.js';
@@ -91,6 +92,20 @@ function resolveDetailedError(error, defaultCode, path) {
 export function buildToolResponse(text, structuredContent, extraContent = []) {
     return buildContentBlock(text, structuredContent, extraContent);
 }
+export function parseToolArgs(schema, args) {
+    const candidate = args === undefined ? {} : args;
+    const parsed = schema.safeParse(candidate);
+    if (parsed.success) {
+        return parsed.data;
+    }
+    throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid tool arguments: ${parsed.error.message}`, undefined, { errors: z.treeifyError(parsed.error) });
+}
+export function withValidatedArgs(schema, handler) {
+    return async (args, extra) => {
+        const normalizedArgs = parseToolArgs(schema, args);
+        return handler(normalizedArgs, extra);
+    };
+}
 function canSendProgress(extra) {
     return (extra._meta?.progressToken !== undefined &&
         extra.sendNotification !== undefined);
@@ -211,9 +226,11 @@ export function createProgressReporter(extra) {
     return (progress) => {
         const { current, total, message } = progress;
         // Enforce monotonic progress to prevent client confusion. Client behavior on
+        // out-of-order progress is undefined in the MCP spec.
         if (current <= lastProgress)
             return;
-        // Enforce rate-limiting to prevent client flooding. Progress updates that are
+        // Enforce rate-limiting to prevent client flooding. Progress updates faster
+        // than PROGRESS_RATE_LIMIT_MS are silently dropped.
         const now = Date.now();
         if (now - lastSentMs < PROGRESS_RATE_LIMIT_MS)
             return;
@@ -266,6 +283,7 @@ async function withProgress(message, extra, run, getCompletionMessage) {
             progressToken: token,
             progress: total,
             total,
+            message: `${message} • failed`,
         });
         throw error;
     }

package/dist/tools/stat-many.js

@@ -4,7 +4,7 @@ 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, GetMultipleFileInfoOutputSchema, } from '../schemas.js';
-import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const GET_MULTIPLE_FILE_INFO_TOOL = {
     title: 'Get Multiple File Info',
@@ -73,19 +73,20 @@ export function registerGetMultipleFileInfoTool(server, options = {}) {
             onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, primaryPath),
         });
     };
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(GetMultipleFileInfoInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         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) => {
+        completionMessage: (args, result) => {
             if (result.isError)
-                return `🕮 stat_many • failed`;
+                return `🕮 stat_many: ${args.paths.length} paths • failed`;
             const sc = result.structuredContent;
             if (!sc.ok)
-                return `🕮 stat_many • failed`;
+                return `🕮 stat_many: ${args.paths.length} paths • failed`;
             const total = sc.summary?.total ?? 0;
             const succeeded = sc.summary?.succeeded ?? 0;
             const failed = sc.summary?.failed ?? 0;

package/dist/tools/stat.js

@@ -4,7 +4,7 @@ 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, GetFileInfoOutputSchema } from '../schemas.js';
-import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, 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.',
@@ -45,7 +45,8 @@ export function registerGetFileInfoTool(server, options = {}) {
         run: (signal) => handleGetFileInfo(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, args.path),
     });
-    server.registerTool('stat', withDefaultIcons({ ...GET_FILE_INFO_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(GetFileInfoInputSchema, handler);
+    server.registerTool('stat', withDefaultIcons({ ...GET_FILE_INFO_TOOL }, options.iconInfo), wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🕮 stat: ${path.basename(args.path)}`,
         completionMessage: (args, result) => {
@@ -55,7 +56,7 @@ export function registerGetFileInfoTool(server, options = {}) {
             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)}]`;
+            return `🕮 stat: ${sc.info.name} • ${sc.info.type}, ${formatBytes(sc.info.size)}`;
         },
     }));
 }

package/dist/tools/task-support.js

@@ -18,6 +18,29 @@ function getExperimentalTaskRegistration(server) {
         return undefined;
     return tasks;
 }
+function hasTaskToolCapability(server) {
+    const maybeServer = server;
+    const serverRuntime = maybeServer.server;
+    const capabilityGetter = serverRuntime?.getCapabilities;
+    if (typeof capabilityGetter !== 'function') {
+        // Fallback for tests or custom wrappers that provide only registerTool/experimental.
+        return true;
+    }
+    const capabilities = capabilityGetter.call(serverRuntime);
+    if (!isRecord(capabilities))
+        return false;
+    const { tasks } = capabilities;
+    if (!isRecord(tasks))
+        return false;
+    const { requests } = tasks;
+    if (!isRecord(requests))
+        return false;
+    const { tools } = requests;
+    if (!isRecord(tools))
+        return false;
+    const { call } = tools;
+    return isRecord(call);
+}
 const RELATED_TASK_META_KEY = 'io.modelcontextprotocol/related-task';
 const TASK_STATUS_NOTIFICATION_METHOD = 'notifications/tasks/status';
 function isRequestTaskStore(value) {
@@ -101,6 +124,35 @@ function normalizeCallToolResult(value) {
         return parsed.data;
     throw new McpError(ErrorCode.E_INVALID_INPUT, 'Stored task result is not a valid tool result.');
 }
+function getToolResultErrorCode(result) {
+    if (!isRecord(result) || result['isError'] !== true)
+        return undefined;
+    const structured = result['structuredContent'];
+    if (!isRecord(structured))
+        return undefined;
+    const { error } = structured;
+    if (!isRecord(error))
+        return undefined;
+    const { code } = error;
+    return typeof code === 'string' ? code : undefined;
+}
+function isCancelledToolResult(result) {
+    return getToolResultErrorCode(result) === ErrorCode.E_CANCELLED;
+}
+async function projectCancelledTaskStatus(taskStore, task) {
+    if (task.status !== 'failed')
+        return task;
+    try {
+        const result = await taskStore.getTaskResult(task.taskId);
+        if (isCancelledToolResult(result)) {
+            return { ...task, status: 'cancelled' };
+        }
+    }
+    catch {
+        // Best effort only: task result may not be available yet.
+    }
+    return task;
+}
 function withRelatedTaskMeta(result, taskId) {
     const existingMeta = isRecord(result['_meta']) ? result['_meta'] : {};
     return {
@@ -129,7 +181,7 @@ async function notifyTaskStatusIfPossible(extra, taskStore, taskId) {
     const notify = sendNotification;
     try {
         const task = await taskStore.getTask(taskId);
-        const normalized = normalizeGetTaskResult(task);
+        const normalized = await projectCancelledTaskStatus(taskStore, normalizeGetTaskResult(task));
         await notify({
             method: TASK_STATUS_NOTIFICATION_METHOD,
             params: buildTaskStatusNotificationParams(normalized),
@@ -159,12 +211,6 @@ const TERMINAL_TASK_STATUSES = new Set([
     'failed',
     'cancelled',
 ]);
-function isTerminalTaskStoreError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const normalized = message.toLowerCase();
-    return (normalized.includes('terminal status') ||
-        normalized.includes('task not found'));
-}
 async function isTaskAlreadyTerminal(taskStore, taskId) {
     try {
         const task = await taskStore.getTask(taskId);
@@ -183,8 +229,7 @@ async function tryStoreTaskResult(taskStore, taskId, status, result) {
         await taskStore.storeTaskResult(taskId, status, resultWithTaskMeta);
     }
     catch (error) {
-        if (isTerminalTaskStoreError(error) ||
-            (await isTaskAlreadyTerminal(taskStore, taskId)))
+        if (await isTaskAlreadyTerminal(taskStore, taskId))
             return;
         throw error;
     }
@@ -213,6 +258,8 @@ async function runTaskInBackground(run, args, extra, taskStore, taskId) {
  * `server.registerTool`.
  */
 export function tryRegisterToolTask(server, toolName, toolDef, taskHandler, iconInfo) {
+    if (!hasTaskToolCapability(server))
+        return false;
     const tasks = getExperimentalTaskRegistration(server);
     if (!tasks?.registerToolTask)
         return false;
@@ -248,7 +295,7 @@ export function createToolTaskHandler(run, options) {
         const taskStore = getTaskStore(extra);
         const taskId = getTaskId(extra);
         const task = await taskStore.getTask(taskId);
-        return normalizeGetTaskResult(task);
+        return projectCancelledTaskStatus(taskStore, normalizeGetTaskResult(task));
     });
     const getTaskResult = (async (argsOrExtra, maybeExtra) => {
         const extra = asTaskRequestExtra(maybeExtra ?? argsOrExtra);

package/dist/tools/tree.js

@@ -3,7 +3,7 @@ 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, TreeOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const TREE_TOOL = {
     title: 'Tree',
@@ -47,7 +47,8 @@ export function registerTreeTool(server, options = {}) {
             onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, targetPath),
         });
     };
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(TreeInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
             if (args.path) {
@@ -55,6 +56,18 @@ export function registerTreeTool(server, options = {}) {
             }
             return '≣ tree';
         },
+        completionMessage: (args, result) => {
+            const base = args.path ? path.basename(args.path) : '.';
+            if (result.isError)
+                return `≣ tree: ${base} • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `≣ tree: ${base} • failed`;
+            const count = sc.totalEntries ?? 0;
+            if (sc.truncated)
+                return `≣ tree: ${base} • ${count} entries [truncated]`;
+            return `≣ tree: ${base} • ${count} ${count === 1 ? 'entry' : 'entries'}`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'tree', TREE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/dist/tools/write-file.js

@@ -4,7 +4,7 @@ import { ErrorCode } from '../lib/errors.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/path-validation.js';
 import { WriteFileInputSchema, WriteFileOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const WRITE_FILE_TOOL = {
     title: 'Write File',
@@ -34,7 +34,8 @@ export function registerWriteFileTool(server, options = {}) {
         run: (signal) => handleWriteFile(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(WriteFileInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🛠 write: ${path.basename(args.path)} [${args.content.length} chars]`,
         completionMessage: (args, result) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "MCP Server that enables LLMs to interact with the local filesystem.",
   "type": "module",