@j0hanz/filesystem-mcp 1.16.2 → 1.16.3

package/dist/server/bootstrap.js

@@ -1,13 +1,10 @@
-import { InMemoryTaskMessageQueue } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { isInitializeRequest, LATEST_PROTOCOL_VERSION, SetLevelRequestSchema, SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
+import { NodeStreamableHTTPServerTransport } from '@modelcontextprotocol/node';
+import { InMemoryTaskMessageQueue, isInitializeRequest, LATEST_PROTOCOL_VERSION, localhostAllowedHostnames, McpServer, StdioServerTransport, SUPPORTED_PROTOCOL_VERSIONS, validateHostHeader, } from '@modelcontextprotocol/server';
 import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
 import { channel } from 'node:diagnostics_channel';
 import { readFile } from 'node:fs/promises';
 import { createServer as createHttpServer, } from 'node:http';
-import { DEFAULT_LOG_LEVEL, parseEnvInt } from '../lib/constants.js';
+import { DEFAULT_LOG_LEVEL, INIT_HANDSHAKE_TIMEOUT_MS, INIT_TIMEOUT_CLOSE, parseEnvInt, } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { createLoggingState, Logger, logToMcp, SessionContext, } from '../lib/logger.js';
 import { withAllowedDirectoriesState } from '../lib/paths.js';
@@ -21,28 +18,6 @@ import { registerAllTools } from '../tools.js';
 import { withDefaultIcons } from '../tools/shared.js';
 import { RootsManager } from './roots-manager.js';
 import { createTaskStore } from './task-store.js';
-let cachedTaskToolSupport;
-function detectTaskToolSupport() {
-    if (cachedTaskToolSupport !== undefined) {
-        return cachedTaskToolSupport;
-    }
-    try {
-        // Instantiate a minimal, unconnected probe server to duck-type check for
-        // task tool support. The probe has no transport or active connections, so
-        // close() only releases in-memory state; fire-and-forget is safe here.
-        const probe = new McpServer({
-            name: 'filesystem-mcp-capability-probe',
-            version: '0.0.0',
-        }, { capabilities: { tools: {} } });
-        cachedTaskToolSupport =
-            typeof probe.experimental.tasks.registerToolTask === 'function';
-        probe.close().catch(() => { });
-    }
-    catch {
-        cachedTaskToolSupport = false;
-    }
-    return cachedTaskToolSupport;
-}
 function buildServerCapabilities(options = {}) {
     const capabilities = {
         logging: {},
@@ -64,13 +39,10 @@ function buildServerCapabilities(options = {}) {
     }
     return capabilities;
 }
-function supportsTaskToolRequests() {
-    return detectTaskToolSupport();
-}
 // Global map of all active servers by sessionId for routing logs
-export const activeServers = new Map();
+const activeServers = new Map();
 // For stdio (single session without a specific ID)
-export let stdioServer;
+let stdioServer;
 function stringifyData(data) {
     if (!data)
         return '';
@@ -123,18 +95,18 @@ export async function createServer(options = {}) {
     const resourceStore = createInMemoryResourceStore();
     const serverInstructions = buildServerInstructions();
     const localIcon = await getLocalIconInfo();
-    const taskToolSupport = supportsTaskToolRequests();
-    const serverConfig = {
-        capabilities: buildServerCapabilities({
-            enablePromptListChanged: false,
-            enableTaskToolRequests: taskToolSupport,
-        }),
-    };
-    if (taskToolSupport) {
-        // Enabling task tool support requires configuring a task store and message queue on the server config. We use in-memory implementations from the SDK which auto-evict tasks after their TTL expires (via setTimeout). Suitable for both stdio and HTTP sessions.
-        serverConfig.taskStore = createTaskStore();
-        serverConfig.taskMessageQueue = new InMemoryTaskMessageQueue();
+    const capabilities = buildServerCapabilities({
+        enablePromptListChanged: false,
+        enableTaskToolRequests: true,
+    });
+    if (capabilities.tasks) {
+        capabilities.tasks = {
+            ...capabilities.tasks,
+            taskStore: createTaskStore(),
+            taskMessageQueue: new InMemoryTaskMessageQueue(),
+        };
     }
+    const serverConfig = { capabilities };
     if (serverInstructions) {
         serverConfig.instructions =
             'filesystem-mcp: Secure local filesystem MCP server. ' +
@@ -153,7 +125,7 @@ export async function createServer(options = {}) {
     rootsManagers.set(server, rootsManager);
     // Subscribe to Logger channel if not already done, but we need to route based on session or fallback to this server if it's stdio.
     // Wait, in stdio there's only one server. In HTTP there are multiple.
-    server.server.setRequestHandler(SetLevelRequestSchema, (req) => {
+    server.server.setRequestHandler('logging/setLevel', (req) => {
         loggingState.minimumLevel = req.params.level;
         Logger.notice(`Log level set to ${req.params.level}`);
         return {};
@@ -181,7 +153,11 @@ export async function createServer(options = {}) {
 export async function startServer(server) {
     const transport = new StdioServerTransport();
     const rootsManager = getRootsManager(server);
-    rootsManager.registerHandlers(server);
+    rootsManager.registerHandlers(server, INIT_TIMEOUT_CLOSE
+        ? () => {
+            void server.close();
+        }
+        : undefined);
     await rootsManager.recomputeAllowedDirectories();
     await server.connect(transport);
     const sdkOnClose = transport.onclose;
@@ -241,7 +217,23 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
     const rootsManager = getRootsManager(mcpServer);
     rootsManager.registerHandlers(mcpServer);
     await rootsManager.recomputeAllowedDirectories();
-    const transport = new StreamableHTTPServerTransport({
+    let cleanedUp = false;
+    const cleanup = () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        const { sessionId } = transport;
+        if (sessionId) {
+            sessions.delete(sessionId);
+            activeServers.delete(sessionId);
+        }
+        rootsManager.destroy();
+    };
+    const close = async () => {
+        cleanup();
+        await mcpServer.close();
+    };
+    const transport = new NodeStreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (sessionId) => {
             sessions.set(sessionId, {
@@ -249,6 +241,9 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
                 rootsManager,
                 transport,
                 negotiatedProtocolVersion,
+                createdAt: Date.now(),
+                cleanup,
+                close,
             });
             activeServers.set(sessionId, {
                 server: mcpServer,
@@ -257,23 +252,16 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
             rootsManager.logMissingDirectoriesIfNeeded(mcpServer);
         },
     });
-    transport.onclose = () => {
-        const { sessionId } = transport;
-        if (sessionId) {
-            sessions.delete(sessionId);
-            activeServers.delete(sessionId);
-        }
-        rootsManager.destroy();
-        mcpServer.close().catch((err) => {
-            Logger.error('[HTTP] Error closing MCP server:', formatUnknownErrorMessage(err));
-        });
-    };
+    transport.onclose = cleanup;
     await mcpServer.connect(transport);
     return {
         server: mcpServer,
         rootsManager,
         transport,
         negotiatedProtocolVersion,
+        createdAt: Date.now(),
+        cleanup,
+        close,
     };
 }
 function sendJsonRpcError(res, status, code, message) {
@@ -296,6 +284,24 @@ function isAllowedOrigin(origin) {
         return true; // Non-browser clients omit Origin.
     return LOCALHOST_ORIGIN_RE.test(origin);
 }
+function normalizeAllowedHostname(host) {
+    const trimmed = host.trim().toLowerCase();
+    if (trimmed === '::1')
+        return '[::1]';
+    return trimmed;
+}
+function getAllowedHostnames(httpHost) {
+    if (isLoopbackHttpHost(httpHost)) {
+        return localhostAllowedHostnames().map(normalizeAllowedHostname);
+    }
+    const normalizedHost = normalizeAllowedHostname(httpHost);
+    if (normalizedHost === '0.0.0.0' ||
+        normalizedHost === '::' ||
+        normalizedHost === '[::]') {
+        return undefined;
+    }
+    return [normalizedHost];
+}
 function getSessionId(req) {
     const rawSessionId = req.headers['mcp-session-id'];
     return typeof rawSessionId === 'string' &&
@@ -359,6 +365,26 @@ function ensureAuthorizedRequest(req, res) {
     writeUnauthorizedResponse(res);
     return false;
 }
+function ensureAllowedOrigin(req, res) {
+    const { origin } = req.headers;
+    if (isAllowedOrigin(origin)) {
+        return true;
+    }
+    sendJsonRpcError(res, 403, JSON_RPC_SERVER_ERROR, 'Forbidden: disallowed origin');
+    return false;
+}
+function ensureAllowedHostHeader(req, res, httpHost) {
+    const allowedHostnames = getAllowedHostnames(httpHost);
+    if (!allowedHostnames || allowedHostnames.length === 0) {
+        return true;
+    }
+    const hostHeader = typeof req.headers['host'] === 'string' ? req.headers['host'] : undefined;
+    const result = validateHostHeader(hostHeader, allowedHostnames);
+    if (result.ok)
+        return true;
+    sendJsonRpcError(res, 403, JSON_RPC_SERVER_ERROR, `Forbidden: ${result.message}`);
+    return false;
+}
 function discardRequestBody(req) {
     req.on('error', () => {
         // Best effort drain to avoid corrupting keep-alive pipelines.
@@ -395,10 +421,49 @@ function assertHttpBindingSecurity(host) {
         return;
     throw new Error(`Refusing to bind HTTP server to non-loopback host '${host}' without FILESYSTEM_MCP_API_KEY.`);
 }
+function writeMethodNotAllowedResponse(res) {
+    res.writeHead(405, {
+        Allow: 'GET, POST, DELETE',
+        'Content-Type': 'application/json',
+    });
+    res.end(JSON.stringify({
+        jsonrpc: '2.0',
+        error: {
+            code: JSON_RPC_SERVER_ERROR,
+            message: 'Method Not Allowed',
+        },
+        id: null,
+    }));
+}
+function handleHttpRequestError(error, res) {
+    if (error instanceof RequestBodyError && !res.headersSent) {
+        const rpcCode = error.statusCode === 413
+            ? JSON_RPC_INVALID_REQUEST
+            : JSON_RPC_PARSE_ERROR;
+        res.setHeader('Connection', 'close');
+        sendJsonRpcError(res, error.statusCode, rpcCode, error.message);
+        return;
+    }
+    Logger.error('[HTTP] Error handling request:', formatUnknownErrorMessage(error));
+    if (!res.headersSent) {
+        sendJsonRpcError(res, 500, JSON_RPC_INTERNAL_ERROR, 'Internal Server Error');
+    }
+}
 export async function startHttpServer(port, options) {
     const sessions = new Map();
     const httpHost = process.env['FILESYSTEM_MCP_HTTP_HOST'] ?? '127.0.0.1';
     assertHttpBindingSecurity(httpHost);
+    let closingSessions;
+    async function closeAllSessions() {
+        if (closingSessions)
+            return closingSessions;
+        closingSessions = (async () => {
+            const activeSessions = [...sessions.values()];
+            sessions.clear();
+            await Promise.allSettled(activeSessions.map((session) => session.close()));
+        })();
+        await closingSessions;
+    }
     async function handlePostRequest(req, res, sessionId) {
         if (sessionId) {
             const session = getSessionOrRespondNotFound(sessions, sessionId, res);
@@ -440,53 +505,48 @@ export async function startHttpServer(port, options) {
             return;
         await handleSessionTransportRequest(session, req, res);
     }
+    async function dispatchMcpMethod(method, req, res, sessionId) {
+        switch (method) {
+            case 'POST':
+                await handlePostRequest(req, res, sessionId);
+                return;
+            case 'GET':
+            case 'DELETE':
+                await handleGetDeleteRequest(req, res, sessionId);
+                return;
+            default:
+                writeMethodNotAllowedResponse(res);
+        }
+    }
     async function handleMcpRequest(req, res) {
-        const { method } = req;
         const sessionId = getSessionId(req);
-        const { origin } = req.headers;
-        if (!isAllowedOrigin(origin)) {
-            sendJsonRpcError(res, 403, JSON_RPC_SERVER_ERROR, 'Forbidden: disallowed origin');
+        if (!ensureAllowedOrigin(req, res))
+            return;
+        if (!ensureAllowedHostHeader(req, res, httpHost))
             return;
-        }
         if (!ensureAuthorizedRequest(req, res))
             return;
         try {
-            if (method === 'POST') {
-                await handlePostRequest(req, res, sessionId);
-            }
-            else if (method === 'GET' || method === 'DELETE') {
-                await handleGetDeleteRequest(req, res, sessionId);
-            }
-            else {
-                res.writeHead(405, {
-                    Allow: 'GET, POST, DELETE',
-                    'Content-Type': 'application/json',
-                });
-                res.end(JSON.stringify({
-                    jsonrpc: '2.0',
-                    error: {
-                        code: JSON_RPC_SERVER_ERROR,
-                        message: 'Method Not Allowed',
-                    },
-                    id: null,
-                }));
-            }
+            await dispatchMcpMethod(req.method, req, res, sessionId);
         }
         catch (error) {
-            if (error instanceof RequestBodyError && !res.headersSent) {
-                const rpcCode = error.statusCode === 413
-                    ? JSON_RPC_INVALID_REQUEST
-                    : JSON_RPC_PARSE_ERROR;
-                res.setHeader('Connection', 'close');
-                sendJsonRpcError(res, error.statusCode, rpcCode, error.message);
-                return;
-            }
-            Logger.error('[HTTP] Error handling request:', formatUnknownErrorMessage(error));
-            if (!res.headersSent) {
-                sendJsonRpcError(res, 500, JSON_RPC_INTERNAL_ERROR, 'Internal Server Error');
-            }
+            handleHttpRequestError(error, res);
         }
     }
+    const SWEEP_INTERVAL_MS = INIT_HANDSHAKE_TIMEOUT_MS * 2;
+    const sweepTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [sessionId, session] of sessions) {
+            if (!session.rootsManager.isInitialized() &&
+                now - session.createdAt > INIT_HANDSHAKE_TIMEOUT_MS) {
+                Logger.warn(`[HTTP] Evicting stale session ${sessionId}: client never sent notifications/initialized`);
+                session.server.close().catch((err) => {
+                    Logger.error(`[HTTP] Error closing stale session ${sessionId}:`, formatUnknownErrorMessage(err));
+                });
+            }
+        }
+    }, SWEEP_INTERVAL_MS);
+    sweepTimer.unref();
     const httpServer = createHttpServer((req, res) => {
         const urlPath = (req.url ?? '/').split('?')[0];
         if (urlPath === '/mcp') {
@@ -499,6 +559,16 @@ export async function startHttpServer(port, options) {
             res.end('Not Found');
         }
     });
+    httpServer.once('close', () => {
+        clearInterval(sweepTimer);
+    });
+    const originalClose = httpServer.close.bind(httpServer);
+    httpServer.close = ((callback) => {
+        void closeAllSessions().catch((error) => {
+            Logger.error('[HTTP] Error closing sessions before server shutdown:', formatUnknownErrorMessage(error));
+        });
+        return originalClose(callback);
+    });
     return new Promise((resolve, reject) => {
         httpServer.once('error', reject);
         httpServer.listen(port, httpHost, () => {

package/dist/server/roots-manager.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type McpServer } from '@modelcontextprotocol/server';
 import { type LoggingState } from '../lib/logger.js';
 import { type AllowedDirectoriesState } from '../lib/paths.js';
 export interface ServerOptions {
@@ -10,6 +10,7 @@ export declare class RootsManager {
     private rootDirectories;
     private allowedDirectoriesState;
     private clientInitialized;
+    private initTimer;
     private updatingRoots;
     private pendingRootsUpdate;
     private readonly options;
@@ -19,7 +20,7 @@ export declare class RootsManager {
     destroy(): void;
     getAllowedDirectoriesState(): AllowedDirectoriesState;
     logMissingDirectoriesIfNeeded(server: McpServer): void;
-    registerHandlers(server: McpServer): void;
+    registerHandlers(server: McpServer, onInitTimeout?: () => void): void;
     recomputeAllowedDirectories(): Promise<void>;
     private scheduleRootsUpdate;
     private logMissingDirectories;

package/dist/server/roots-manager.js

@@ -1,13 +1,16 @@
-import { InitializedNotificationSchema, RootsListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
+import {} from '@modelcontextprotocol/server';
+import { channel } from 'node:diagnostics_channel';
 import { realpath } from 'node:fs/promises';
 import { z } from 'zod';
 import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/abort.js';
+import { INIT_HANDSHAKE_TIMEOUT_MS } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { Logger, logToMcp } from '../lib/logger.js';
 import { getValidRootDirectories, isPathWithinDirectories, normalizePath, resolveAllowedDirectoriesState, setAllowedDirectoriesStateResolved, } from '../lib/paths.js';
 import { debounce, isRecord } from '../lib/utils.js';
 const ROOTS_TIMEOUT_MS = 5000;
 const ROOTS_DEBOUNCE_MS = 100;
+const LIFECYCLE_CHANNEL = channel('filesystem-mcp:lifecycle');
 function normalizeCLIDirectories(dirs) {
     const normalized = [];
     for (const dir of dirs) {
@@ -88,6 +91,7 @@ export class RootsManager {
         expanded: [],
     };
     clientInitialized = false;
+    initTimer;
     // Guard concurrent root refreshes; if one is already running we queue one
     // replay so the last-known state still gets applied after completion.
     updatingRoots = false;
@@ -103,6 +107,10 @@ export class RootsManager {
         return this.clientInitialized;
     }
     destroy() {
+        if (this.initTimer) {
+            clearTimeout(this.initTimer);
+            this.initTimer = undefined;
+        }
         if (this._debouncedUpdate) {
             this._debouncedUpdate.cancel();
             this._debouncedUpdate = undefined;
@@ -119,16 +127,34 @@ export class RootsManager {
             this.logMissingDirectories(server);
         }
     }
-    registerHandlers(server) {
-        server.server.setNotificationHandler(InitializedNotificationSchema, async () => {
+    registerHandlers(server, onInitTimeout) {
+        server.server.setNotificationHandler('notifications/initialized', async () => {
+            if (this.initTimer) {
+                clearTimeout(this.initTimer);
+                this.initTimer = undefined;
+            }
             this.clientInitialized = true;
             await this.updateRootsFromClient(server);
         });
-        server.server.setNotificationHandler(RootsListChangedNotificationSchema, () => {
+        server.server.setNotificationHandler('notifications/roots/list_changed', () => {
             if (!this.clientInitialized)
                 return;
             this.scheduleRootsUpdate(server);
         });
+        this.initTimer = setTimeout(() => {
+            if (!this.clientInitialized) {
+                if (LIFECYCLE_CHANNEL.hasSubscribers) {
+                    LIFECYCLE_CHANNEL.publish({
+                        phase: 'init_timeout',
+                        timeoutMs: INIT_HANDSHAKE_TIMEOUT_MS,
+                    });
+                }
+                logToMcp(server, 'warning', `Client did not send notifications/initialized within ${String(INIT_HANDSHAKE_TIMEOUT_MS)}ms`, this.loggingState.minimumLevel);
+                onInitTimeout?.();
+            }
+            this.initTimer = undefined;
+        }, INIT_HANDSHAKE_TIMEOUT_MS);
+        this.initTimer.unref();
     }
     async recomputeAllowedDirectories() {
         const cliAllowedDirs = normalizeCLIDirectories(this.options.cliAllowedDirs ?? []);

package/dist/server/task-store.d.ts

@@ -1,10 +1,9 @@
-import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
-import type { Result } from '@modelcontextprotocol/sdk/types.js';
+import { InMemoryTaskStore, type Result, type Task } from '@modelcontextprotocol/server';
 export declare class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
     private readonly cancelledResults;
     getTaskResult(taskId: string, sessionId?: string): Promise<Result>;
     storeTaskResult(taskId: string, status: 'completed' | 'failed', result: Result, sessionId?: string): Promise<void>;
-    updateTaskStatus(taskId: string, status: 'working' | 'input_required' | 'completed' | 'failed' | 'cancelled', statusMessage?: string, sessionId?: string): Promise<void>;
+    updateTaskStatus(taskId: string, status: Task['status'], statusMessage?: string, sessionId?: string): Promise<void>;
     cleanup(): void;
 }
 export declare function createTaskStore(): ResultAwareInMemoryTaskStore;

package/dist/server/task-store.js

@@ -1,4 +1,4 @@
-import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
+import { InMemoryTaskStore, } from '@modelcontextprotocol/server';
 import { ErrorCode } from '../lib/errors.js';
 const DEFAULT_CANCELLED_STATUS_MESSAGE = 'Client cancelled task execution.';
 function getTaskKey(taskId, sessionId) {

package/dist/tools/apply-patch.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 APPLY_PATCH_TOOL: ToolContract;
 export declare function registerApplyPatchTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/apply-patch.js

@@ -8,8 +8,9 @@ import { atomicWriteFile, processInParallel } from '../lib/fs-helpers.js';
 import { Logger } from '../lib/logger.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { ApplyPatchInputSchema, ApplyPatchOutputSchema } 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_EDIT_ICONS } from './icons.js';
+import { buildStructuredError, buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const APPLY_PATCH_TOOL = {
     name: 'apply_patch',
     title: 'Apply Patch',
@@ -20,10 +21,11 @@ export const APPLY_PATCH_TOOL = {
     inputSchema: ApplyPatchInputSchema,
     outputSchema: ApplyPatchOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
+    icons: FILE_EDIT_ICONS,
     nuances: [
         'Multi-file patches use `path` as base directory; per-file results in `results[]`.',
     ],
-    taskSupport: 'forbidden',
+    taskSupport: 'optional',
 };
 function assertPatchTargetSizeWithinLimit(filePath, size, maxFileSize) {
     if (size <= maxFileSize)
@@ -187,17 +189,23 @@ async function handleApplyPatch(args, signal) {
     });
 }
 export function registerApplyPatchTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'apply_patch',
-        extra,
+        ctx,
         outputSchema: ApplyPatchOutputSchema,
         timedSignal: {},
         context: { path: args.path },
-        run: (signal) => handleApplyPatch(args, signal),
+        run: async (signal) => {
+            const result = await handleApplyPatch(args, signal);
+            if (!args.dryRun) {
+                const sc = result.structuredContent;
+                void ctx.log?.('info', `patch: ${args.path} (+${String(sc.linesAdded ?? 0)}/-${String(sc.linesRemoved ?? 0)})`);
+            }
+            return result;
+        },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, APPLY_PATCH_TOOL, handler, options, {
         progressMessage: (args) => {
             const name = basename(args.path);
             return args.dryRun ? `🛠 patch: ${name} [dry run]` : `🛠 patch: ${name}`;
@@ -217,8 +225,4 @@ export function registerApplyPatchTool(server, options = {}) {
             return `🛠 patch: ${name} • ${dry}no changes`;
         },
     });
-    const validatedHandler = withValidatedArgs(ApplyPatchInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'apply_patch', APPLY_PATCH_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('apply_patch', withDefaultIcons({ ...APPLY_PATCH_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/calculate-hash.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 CALCULATE_HASH_TOOL: ToolContract;
 export declare function registerCalculateHashTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/calculate-hash.js

@@ -10,8 +10,9 @@ import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations
 import { globEntries } from '../lib/file-operations/traversal.js';
 import { validateExistingPath } from '../lib/paths.js';
 import { CalculateHashInputSchema, CalculateHashOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, 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 { buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 const WINDOWS_PATH_SEPARATOR = /\\/gu;
 export const CALCULATE_HASH_TOOL = {
     name: 'calculate_hash',
@@ -20,6 +21,7 @@ export const CALCULATE_HASH_TOOL = {
     inputSchema: CalculateHashInputSchema,
     outputSchema: CalculateHashOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: FILE_READ_ICONS,
     nuances: [
         'Directory hashing respects root `.gitignore` and sorts paths for stable output.',
     ],
@@ -143,15 +145,15 @@ async function handleCalculateHash(args, signal, onProgress) {
     }
 }
 export function registerCalculateHashTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'calculate_hash',
-        extra,
+        ctx,
         outputSchema: CalculateHashOutputSchema,
         timedSignal: {},
         context: { path: args.path },
         run: async (signal) => {
             const baseName = basename(args.path);
-            const progress = createToolProgressSession(extra, `🕮 hash: ${baseName}`);
+            const progress = createToolProgressSession(ctx, `🕮 hash: ${baseName}`);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
                     current,
@@ -181,11 +183,5 @@ export function registerCalculateHashTool(server, options = {}) {
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
-    });
-    const validatedHandler = withValidatedArgs(CalculateHashInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'calculate_hash', CALCULATE_HASH_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('calculate_hash', withDefaultIcons({ ...CALCULATE_HASH_TOOL }, options.iconInfo), validatedHandler);
+    registerStandardTool(server, CALCULATE_HASH_TOOL, handler, options);
 }

package/dist/tools/contract.d.ts

@@ -1,3 +1,4 @@
+import type { Icon } from '@modelcontextprotocol/server';
 import type { ZodType } from 'zod';
 export interface ToolContract {
     /**
@@ -38,6 +39,10 @@ export interface ToolContract {
      * Common pitfalls or warnings for documentation.
      */
     gotchas?: string[];
+    /**
+     * Optional icons for display in user interfaces.
+     */
+    icons?: Icon[];
     /**
      * Task support level for the tool. Defaults to 'forbidden'.
      */

package/dist/tools/create-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 CREATE_DIRECTORY_TOOL: ToolContract;
 export declare function registerCreateDirectoryTool(server: McpServer, options?: ToolRegistrationOptions): void;