@j0hanz/filesystem-mcp 1.16.2 → 1.16.3

package/dist/tools/create-directory.js

@@ -4,8 +4,9 @@ import { withAbort } from '../lib/abort.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { validatePathForWrite } from '../lib/paths.js';
 import { CreateDirectoryInputSchema, CreateDirectoryOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, IDEMPOTENT_WRITE_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { DIR_CREATE_ICONS } from './icons.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, IDEMPOTENT_WRITE_TOOL_ANNOTATIONS, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const CREATE_DIRECTORY_TOOL = {
     name: 'mkdir',
     title: 'Create Directory',
@@ -13,6 +14,7 @@ export const CREATE_DIRECTORY_TOOL = {
     inputSchema: CreateDirectoryInputSchema,
     outputSchema: CreateDirectoryOutputSchema,
     annotations: IDEMPOTENT_WRITE_TOOL_ANNOTATIONS,
+    icons: DIR_CREATE_ICONS,
     taskSupport: 'forbidden',
 };
 async function handleCreateDirectory(args, signal) {
@@ -34,17 +36,16 @@ async function handleCreateDirectory(args, signal) {
     });
 }
 export function registerCreateDirectoryTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'mkdir',
-        extra,
+        ctx,
         outputSchema: CreateDirectoryOutputSchema,
         timedSignal: {},
         context: { path: args.path ?? args.paths?.[0] },
         run: (signal) => handleCreateDirectory(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path ?? args.paths?.[0]),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, CREATE_DIRECTORY_TOOL, handler, options, {
         progressMessage: (args) => {
             if (args.path && !args.paths?.length) {
                 return `🛠 mkdir: ${basename(args.path)}`;
@@ -65,8 +66,4 @@ export function registerCreateDirectoryTool(server, options = {}) {
             return `🛠 mkdir: ${count} directories`;
         },
     });
-    const validatedHandler = withValidatedArgs(CreateDirectoryInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'mkdir', CREATE_DIRECTORY_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('mkdir', withDefaultIcons({ ...CREATE_DIRECTORY_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/delete-file.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const DELETE_FILE_TOOL: ToolContract;
 export declare function registerDeleteFileTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/delete-file.js

@@ -5,8 +5,9 @@ import { ErrorCode, isNodeError, McpError } from '../lib/errors.js';
 import { Logger } from '../lib/logger.js';
 import { isAllowedDirectoryRoot, validatePathForWrite } from '../lib/paths.js';
 import { DeleteFileInputSchema, DeleteFileOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_DELETE_ICONS } from './icons.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const DELETE_FILE_TOOL = {
     name: 'rm',
     title: 'Delete File',
@@ -14,6 +15,7 @@ export const DELETE_FILE_TOOL = {
     inputSchema: DeleteFileInputSchema,
     outputSchema: DeleteFileOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
+    icons: FILE_DELETE_ICONS,
     gotchas: ['Non-empty directories require `recursive=true`.'],
     taskSupport: 'forbidden',
 };
@@ -55,13 +57,17 @@ async function handleDeleteFile(args, signal) {
     });
 }
 export function registerDeleteFileTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'rm',
-        extra,
+        ctx,
         outputSchema: DeleteFileOutputSchema,
         timedSignal: {},
         context: { path: args.path },
-        run: (signal) => handleDeleteFile(args, signal),
+        run: async (signal) => {
+            const result = await handleDeleteFile(args, signal);
+            void ctx.log?.('info', `rm: ${args.path}`);
+            return result;
+        },
         onError: (error) => {
             if (isNodeError(error)) {
                 if (error.code === 'ENOENT') {
@@ -83,8 +89,7 @@ export function registerDeleteFileTool(server, options = {}) {
             return buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path);
         },
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, DELETE_FILE_TOOL, handler, options, {
         progressMessage: (args) => `🛠 rm: ${basename(args.path)}`,
         completionMessage: (args, result) => {
             const name = basename(args.path);
@@ -93,8 +98,4 @@ export function registerDeleteFileTool(server, options = {}) {
             return `🛠 rm: ${name}`;
         },
     });
-    const validatedHandler = withValidatedArgs(DeleteFileInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'rm', DELETE_FILE_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('rm', withDefaultIcons({ ...DELETE_FILE_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/diff-files.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const DIFF_FILES_TOOL: ToolContract;
 export declare function registerDiffFilesTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/diff-files.js

@@ -6,8 +6,9 @@ import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { validateExistingPath } from '../lib/paths.js';
 import { DiffFilesInputSchema, DiffFilesOutputSchema } from '../schemas.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_READ_ICONS } from './icons.js';
+import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const DIFF_FILES_TOOL = {
     name: 'diff_files',
     title: 'Diff Files',
@@ -17,7 +18,8 @@ export const DIFF_FILES_TOOL = {
     inputSchema: DiffFilesInputSchema,
     outputSchema: DiffFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    taskSupport: 'forbidden',
+    icons: FILE_READ_ICONS,
+    taskSupport: 'optional',
 };
 function computeDiffStats(hunks) {
     let linesAdded = 0;
@@ -101,17 +103,16 @@ async function handleDiffFiles(args, signal, resourceStore) {
     ]);
 }
 export function registerDiffFilesTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'diff_files',
-        extra,
+        ctx,
         outputSchema: DiffFilesOutputSchema,
         timedSignal: {},
         context: { path: args.original },
         run: (signal) => handleDiffFiles(args, signal, options.resourceStore),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.original),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, DIFF_FILES_TOOL, handler, options, {
         progressMessage: (args) => {
             const n1 = basename(args.original);
             const n2 = basename(args.modified);
@@ -132,8 +133,4 @@ export function registerDiffFilesTool(server, options = {}) {
             return `🕮 diff: ${n1} ⟷ ${n2}`;
         },
     });
-    const validatedHandler = withValidatedArgs(DiffFilesInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'diff_files', DIFF_FILES_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('diff_files', withDefaultIcons({ ...DIFF_FILES_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/edit-file.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const EDIT_FILE_TOOL: ToolContract;
 export declare function registerEditFileTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/edit-file.js

@@ -9,8 +9,9 @@ import { atomicWriteFile } from '../lib/fs-helpers.js';
 import { Logger } from '../lib/logger.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { EditFileInputSchema, EditFileOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_EDIT_ICONS } from './icons.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const EDIT_FILE_TOOL = {
     name: 'edit',
     title: 'Edit File',
@@ -20,6 +21,7 @@ export const EDIT_FILE_TOOL = {
     inputSchema: EditFileInputSchema,
     outputSchema: EditFileOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
+    icons: FILE_EDIT_ICONS,
     nuances: ['Each edit applies to the output of the previous edit.'],
     taskSupport: 'forbidden',
 };
@@ -229,22 +231,21 @@ async function handleEditFile(args, signal) {
     return buildToolResponse(buildEditMessage(args.path, editResult), structured);
 }
 export function registerEditFileTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'edit',
-        extra,
+        ctx,
         outputSchema: EditFileOutputSchema,
         timedSignal: {},
         context: { path: args.path },
-        run: (signal) => handleEditFile(args, signal),
+        run: async (signal) => {
+            const result = await handleEditFile(args, signal);
+            void ctx.log?.('info', `edit: ${args.path} (${String(result.structuredContent.appliedEdits ?? 0)} edits)`);
+            return result;
+        },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, EDIT_FILE_TOOL, handler, options, {
         progressMessage: buildEditProgressMessage,
         completionMessage: buildEditCompletionMessage,
     });
-    const validatedHandler = withValidatedArgs(EditFileInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'edit', EDIT_FILE_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('edit', withDefaultIcons({ ...EDIT_FILE_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/icons.d.ts

@@ -0,0 +1,15 @@
+import type { Icon } from '@modelcontextprotocol/server';
+/** Document with lines — read, read_many, stat, stat_many, calculate_hash, diff_files */
+export declare const FILE_READ_ICONS: Icon[];
+/** Folder — ls, tree, find, roots */
+export declare const DIRECTORY_ICONS: Icon[];
+/** Magnifying glass — grep */
+export declare const SEARCH_ICONS: Icon[];
+/** Pencil — write, edit, apply_patch, search_and_replace */
+export declare const FILE_EDIT_ICONS: Icon[];
+/** Arrow — mv */
+export declare const FILE_MOVE_ICONS: Icon[];
+/** Trash — rm */
+export declare const FILE_DELETE_ICONS: Icon[];
+/** Folder with plus — mkdir */
+export declare const DIR_CREATE_ICONS: Icon[];

package/dist/tools/icons.js

@@ -0,0 +1,24 @@
+const MIME = 'image/svg+xml';
+function svgIcon(paths) {
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">${paths}</svg>`;
+    return [
+        {
+            src: `data:${MIME};base64,${Buffer.from(svg).toString('base64')}`,
+            mimeType: MIME,
+        },
+    ];
+}
+/** Document with lines — read, read_many, stat, stat_many, calculate_hash, diff_files */
+export const FILE_READ_ICONS = svgIcon('<path d="M4 1h5l4 4v9a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1z"/><path d="M9 1v4h4"/><path d="M6 8h4M6 11h3"/>');
+/** Folder — ls, tree, find, roots */
+export const DIRECTORY_ICONS = svgIcon('<path d="M2 4h4l2 2h6v7a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1z"/>');
+/** Magnifying glass — grep */
+export const SEARCH_ICONS = svgIcon('<circle cx="6.5" cy="6.5" r="4"/><path d="M10 10l4 4"/>');
+/** Pencil — write, edit, apply_patch, search_and_replace */
+export const FILE_EDIT_ICONS = svgIcon('<path d="M11 2l3 3-9 9H2v-3z"/>');
+/** Arrow — mv */
+export const FILE_MOVE_ICONS = svgIcon('<path d="M2 8h12M10 4l4 4-4 4"/>');
+/** Trash — rm */
+export const FILE_DELETE_ICONS = svgIcon('<path d="M3 4h10M5.5 4V3h5v1"/><path d="M4 4l.7 9.5h6.6L12 4"/>');
+/** Folder with plus — mkdir */
+export const DIR_CREATE_ICONS = svgIcon('<path d="M2 4h4l2 2h6v7a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1z"/><path d="M8 9v3M6.5 10.5h3"/>');

package/dist/tools/list-directory.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const LIST_DIRECTORY_TOOL: ToolContract;
 export declare function registerListDirectoryTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/list-directory.js

@@ -7,8 +7,9 @@ import { listDirectory } from '../lib/file-operations/metadata.js';
 import { createBase64JsonCodec } from '../lib/zod-codecs.js';
 import { formatOperationSummary, joinLines } from '../config.js';
 import { ListDirectoryInputSchema, ListDirectoryOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { DIRECTORY_ICONS } from './icons.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const LIST_DIRECTORY_TOOL = {
     name: 'ls',
     title: 'List Directory',
@@ -18,6 +19,7 @@ export const LIST_DIRECTORY_TOOL = {
     inputSchema: ListDirectoryInputSchema,
     outputSchema: ListDirectoryOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: DIRECTORY_ICONS,
     taskSupport: 'optional',
     nuances: ['`pattern` enables filtered recursive traversal up to `maxDepth`.'],
 };
@@ -194,16 +196,15 @@ async function handleListDirectory(args, signal) {
     return buildToolResponse(buildListTextResult(displayResult, nextCursor), buildStructuredListResult(displayResult, nextCursor));
 }
 export function registerListDirectoryTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'ls',
-        extra,
+        ctx,
         outputSchema: ListDirectoryOutputSchema,
         context: { path: args.path ?? '.' },
         run: (signal) => handleListDirectory(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_DIRECTORY, args.path ?? '.'),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, LIST_DIRECTORY_TOOL, handler, options, {
         progressMessage: (args) => `≣ ls: ${args.path ? basename(args.path) : '.'}`,
         completionMessage: (args, result) => {
             const base = args.path ? basename(args.path) : '.';
@@ -214,8 +215,4 @@ export function registerListDirectoryTool(server, options = {}) {
             return `≣ ls: ${base} • ${count} ${count === 1 ? 'entry' : 'entries'}`;
         },
     });
-    const validatedHandler = withValidatedArgs(ListDirectoryInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'ls', LIST_DIRECTORY_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('ls', withDefaultIcons({ ...LIST_DIRECTORY_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/move-file.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const MOVE_FILE_TOOL: ToolContract;
 export declare function registerMoveFileTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/move-file.js

@@ -5,8 +5,9 @@ import { ErrorCode, formatUnknownErrorMessage, isNodeError, McpError, } from '..
 import { Logger } from '../lib/logger.js';
 import { assertAllowedFileAccess, validateExistingPath, validatePathForWrite, } from '../lib/paths.js';
 import { MoveFileInputSchema, MoveFileOutputSchema } from '../schemas.js';
-import { buildStructuredError, buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_MOVE_ICONS } from './icons.js';
+import { buildStructuredError, buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const MOVE_FILE_TOOL = {
     name: 'mv',
     title: 'Move File',
@@ -14,6 +15,7 @@ export const MOVE_FILE_TOOL = {
     inputSchema: MoveFileInputSchema,
     outputSchema: MoveFileOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
+    icons: FILE_MOVE_ICONS,
     gotchas: [
         'On POSIX, an existing destination is silently overwritten; on Windows, rename fails with EEXIST if destination exists.',
     ],
@@ -138,17 +140,20 @@ async function handleMoveFile(args, signal) {
     });
 }
 export function registerMoveFileTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'mv',
-        extra,
+        ctx,
         outputSchema: MoveFileOutputSchema,
         timedSignal: {},
         context: { path: args.source ?? args.sources?.[0] },
-        run: (signal) => handleMoveFile(args, signal),
+        run: async (signal) => {
+            const result = await handleMoveFile(args, signal);
+            void ctx.log?.('info', `mv: ${args.source ?? args.sources?.join(', ') ?? ''} \u2192 ${args.destination}`);
+            return result;
+        },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.source ?? args.sources?.[0]),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, MOVE_FILE_TOOL, handler, options, {
         progressMessage: (args) => {
             const dest = basename(args.destination);
             if (args.source && !args.sources?.length) {
@@ -171,8 +176,4 @@ export function registerMoveFileTool(server, options = {}) {
             return `🛠 mv: ${count} items → ${dest}`;
         },
     });
-    const validatedHandler = withValidatedArgs(MoveFileInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'mv', MOVE_FILE_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('mv', withDefaultIcons({ ...MOVE_FILE_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/read-multiple.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const READ_MANY_TOOL: ToolContract;
 export declare function registerReadMultipleFilesTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/read-multiple.js

@@ -3,8 +3,9 @@ import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { readMultipleFiles } from '../lib/file-operations/metadata.js';
 import { ReadMultipleFilesInputSchema, ReadMultipleFilesOutputSchema, } from '../schemas.js';
-import { buildBatchCompletionSuffix, buildBatchPathContext, buildResourceLink, buildStructuredError, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_READ_ICONS } from './icons.js';
+import { buildBatchCompletionSuffix, buildBatchPathContext, buildResourceLink, buildStructuredError, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 const READ_MANY_TOOL_NAME = 'read_many';
 const READ_MANY_TOOL_LABEL = '🕮 read_many';
 const FULL_FILE_CONTENTS_DESCRIPTION = 'Full file contents';
@@ -16,6 +17,7 @@ export const READ_MANY_TOOL = {
     inputSchema: ReadMultipleFilesInputSchema,
     outputSchema: ReadMultipleFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: FILE_READ_ICONS,
     taskSupport: 'optional',
 };
 function buildReadManyResourceName(filePath) {
@@ -161,17 +163,17 @@ async function handleReadMultipleFiles(args, signal, resourceStore, onReadComple
     return buildToolResponse(payload.text, structured, payload.resourceLinks);
 }
 export function registerReadMultipleFilesTool(server, options = {}) {
-    const handler = (args, extra) => {
+    const handler = (args, ctx) => {
         const primaryPath = args.paths[0] ?? '';
         return executeToolWithDiagnostics({
             toolName: READ_MANY_TOOL_NAME,
-            extra,
+            ctx,
             outputSchema: ReadMultipleFilesOutputSchema,
             timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
             context: { path: primaryPath },
             run: async (signal) => {
                 const context = buildBatchPathContext(args.paths, 'files');
-                const { progress, onItemComplete } = createBatchProgressCallbacks(extra, {
+                const { progress, onItemComplete } = createBatchProgressCallbacks(ctx, {
                     toolLabel: READ_MANY_TOOL_LABEL,
                     context,
                     totalItems: args.paths.length,
@@ -194,11 +196,5 @@ export function registerReadMultipleFilesTool(server, options = {}) {
             onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_FILE, primaryPath),
         });
     };
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
-    });
-    const validatedHandler = withValidatedArgs(ReadMultipleFilesInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, READ_MANY_TOOL_NAME, READ_MANY_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool(READ_MANY_TOOL_NAME, withDefaultIcons({ ...READ_MANY_TOOL }, options.iconInfo), validatedHandler);
+    registerStandardTool(server, READ_MANY_TOOL, handler, options);
 }

package/dist/tools/read.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const READ_FILE_TOOL: ToolContract;
 export declare function registerReadFileTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/read.js

@@ -4,8 +4,9 @@ import { DEFAULT_SEARCH_TIMEOUT_MS, MAX_TEXT_FILE_SIZE, } from '../lib/constants
 import { ErrorCode } from '../lib/errors.js';
 import { readFile } from '../lib/fs-helpers.js';
 import { ReadFileInputSchema, ReadFileOutputSchema } from '../schemas.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_READ_ICONS } from './icons.js';
+import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const READ_FILE_TOOL = {
     name: 'read',
     title: 'Read File',
@@ -15,6 +16,7 @@ export const READ_FILE_TOOL = {
     inputSchema: ReadFileInputSchema,
     outputSchema: ReadFileOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: FILE_READ_ICONS,
     nuances: [
         'Large content is externalized to `filesystem-mcp://result/{id}` and preview is returned inline.',
     ],
@@ -153,22 +155,17 @@ async function handleReadFile(args, signal, resourceStore) {
     return buildToolResponse(result.content, structured);
 }
 export function registerReadFileTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: READ_TOOL_NAME,
-        extra,
+        ctx,
         outputSchema: ReadFileOutputSchema,
         timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
         context: { path: args.path },
         run: (signal) => handleReadFile(args, signal, options.resourceStore),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_FILE, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, READ_FILE_TOOL, handler, options, {
         progressMessage: buildReadProgressMessage,
         completionMessage: buildReadCompletionMessage,
     });
-    const validatedHandler = withValidatedArgs(ReadFileInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, READ_TOOL_NAME, READ_FILE_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool(READ_TOOL_NAME, withDefaultIcons({ ...READ_FILE_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/replace-in-files.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const SEARCH_AND_REPLACE_TOOL: ToolContract;
 export declare function registerSearchAndReplaceTool(server: McpServer, options?: ToolRegistrationOptions): void;

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

@@ -10,8 +10,9 @@ import { atomicWriteFile } from '../lib/fs-helpers.js';
 import { Logger } from '../lib/logger.js';
 import { validateExistingPath, validatePathForWrite } from '../lib/paths.js';
 import { SearchAndReplaceInputSchema, SearchAndReplaceOutputSchema, } from '../schemas.js';
-import { buildStructuredError, buildToolErrorResponse, buildToolResponse, createToolProgressSession, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_EDIT_ICONS } from './icons.js';
+import { buildStructuredError, buildToolErrorResponse, buildToolResponse, createToolProgressSession, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const SEARCH_AND_REPLACE_TOOL = {
     name: 'search_and_replace',
     title: 'Search and Replace',
@@ -22,6 +23,7 @@ export const SEARCH_AND_REPLACE_TOOL = {
     inputSchema: SearchAndReplaceInputSchema,
     outputSchema: SearchAndReplaceOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
+    icons: FILE_EDIT_ICONS,
     taskSupport: 'optional',
 };
 const MAX_FAILURES = 20;
@@ -328,9 +330,9 @@ async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
     return buildToolResponse(buildSearchAndReplaceText(summary, args.dryRun), buildSearchAndReplaceStructuredResult(summary, args));
 }
 export function registerSearchAndReplaceTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'search_and_replace',
-        extra,
+        ctx,
         outputSchema: SearchAndReplaceOutputSchema,
         timedSignal: {},
         ...(args.path ? { context: { path: args.path } } : {}),
@@ -338,7 +340,7 @@ export function registerSearchAndReplaceTool(server, options = {}) {
             const dryLabel = args.dryRun ? ' [dry run]' : '';
             const truncatedPattern = truncateProgressPattern(args.searchPattern);
             const context = `"${truncatedPattern}" in ${args.filePattern}${dryLabel}`;
-            const progress = createToolProgressSession(extra, `🛠 replace: ${context}`);
+            const progress = createToolProgressSession(ctx, `🛠 replace: ${context}`);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
                     current,
@@ -356,6 +358,9 @@ export function registerSearchAndReplaceTool(server, options = {}) {
                 if (sc.failedFiles)
                     endSuffix += `, ${sc.failedFiles} failed`;
                 progress.complete(`🛠 replace: ${context} • ${endSuffix}`, finalCurrent);
+                if (!args.dryRun) {
+                    void ctx.log?.('info', `search_and_replace: ${String(sc.matches ?? 0)} matches in ${String(sc.filesChanged ?? 0)} files`);
+                }
                 return result;
             }
             catch (error) {
@@ -365,14 +370,7 @@ export function registerSearchAndReplaceTool(server, options = {}) {
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
-    const { isInitialized } = options;
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: isInitialized,
-    });
-    const validatedHandler = withValidatedArgs(SearchAndReplaceInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'search_and_replace', SEARCH_AND_REPLACE_TOOL, validatedHandler, options.iconInfo, isInitialized))
-        return;
-    server.registerTool('search_and_replace', withDefaultIcons({ ...SEARCH_AND_REPLACE_TOOL }, options.iconInfo), validatedHandler);
+    registerStandardTool(server, SEARCH_AND_REPLACE_TOOL, handler, options);
 }
 function buildSearchAndReplaceText(summary, dryRun) {
     const failureSuffix = summary.failedFiles > 0 ? ` (${summary.failedFiles} failed)` : '';

package/dist/tools/roots.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const LIST_ALLOWED_DIRECTORIES_TOOL: ToolContract;
 export declare function registerListAllowedDirectoriesTool(server: McpServer, options?: ToolRegistrationOptions): void;