@j0hanz/filesystem-mcp 1.2.1 → 1.2.3

package/dist/server.js

@@ -1,346 +1 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { InMemoryTaskMessageQueue, InMemoryTaskStore, } 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 { InitializedNotificationSchema, RootsListChangedNotificationSchema, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import packageJsonRaw from '../package.json' with { type: 'json' };
-import { registerCompletions } from './completions.js';
-import { formatUnknownErrorMessage } from './lib/errors.js';
-import { assertNotAborted, createTimedAbortSignal, withAbort, } from './lib/fs-helpers.js';
-import { getAllowedDirectories, getValidRootDirectories, isPathWithinDirectories, normalizePath, setAllowedDirectoriesResolved, } from './lib/path-validation.js';
-import { createInMemoryResourceStore } from './lib/resource-store.js';
-import { isRecord } from './lib/type-guards.js';
-import { registerGetHelpPrompt } from './prompts.js';
-import { registerInstructionResource, registerResultResources, } from './resources.js';
-import { registerAllTools } from './tools.js';
-import { withDefaultIcons } from './tools/shared.js';
-const PackageJsonSchema = z.object({
-    version: z.string(),
-    description: z.string().optional(),
-    homepage: z.string().optional(),
-});
-const { version: SERVER_VERSION, description: SERVER_DESCRIPTION, homepage: SERVER_HOMEPAGE, } = PackageJsonSchema.parse(packageJsonRaw);
-function normalizeCLIDirectories(dirs) {
-    const normalized = [];
-    for (const dir of dirs) {
-        const trimmed = dir.trim();
-        if (trimmed.length === 0)
-            continue;
-        normalized.push(normalizePath(trimmed));
-    }
-    return normalized;
-}
-const ROOTS_TIMEOUT_MS = 5000;
-const ROOTS_DEBOUNCE_MS = 100;
-const MCP_LOGGER_NAME = 'filesystem-mcp';
-const LOG_LEVEL_ORDER = {
-    debug: 0,
-    info: 1,
-    notice: 2,
-    warning: 3,
-    error: 4,
-    critical: 5,
-    alert: 6,
-    emergency: 7,
-};
-function canSendMcpLogs(server) {
-    const capabilities = server.server.getClientCapabilities();
-    if (!isRecord(capabilities))
-        return false;
-    if (!('logging' in capabilities))
-        return false;
-    return Boolean(capabilities.logging);
-}
-function logToMcp(server, level, data, minLevel = 'debug') {
-    if (LOG_LEVEL_ORDER[level] < LOG_LEVEL_ORDER[minLevel]) {
-        return;
-    }
-    if (!server || !canSendMcpLogs(server)) {
-        console.error(data);
-        return;
-    }
-    const params = {
-        level,
-        logger: MCP_LOGGER_NAME,
-        data,
-    };
-    void server.sendLoggingMessage(params).catch((error) => {
-        console.error(`Failed to send MCP log: ${level} │ ${data}`, formatUnknownErrorMessage(error));
-    });
-}
-class RootsManager {
-    rootsUpdateTimeout;
-    rootDirectories = [];
-    clientInitialized = false;
-    options;
-    loggingState;
-    constructor(options, loggingState) {
-        this.options = options;
-        this.loggingState = loggingState ?? { minimumLevel: 'debug' };
-    }
-    isInitialized() {
-        return this.clientInitialized;
-    }
-    logMissingDirectoriesIfNeeded(server) {
-        if (getAllowedDirectories().length === 0) {
-            this.logMissingDirectories(server);
-        }
-    }
-    registerHandlers(server) {
-        server.server.setNotificationHandler(InitializedNotificationSchema, async () => {
-            this.clientInitialized = true;
-            await this.updateRootsFromClient(server);
-        });
-        server.server.setNotificationHandler(RootsListChangedNotificationSchema, () => {
-            if (!this.clientInitialized)
-                return;
-            this.scheduleRootsUpdate(server);
-        });
-    }
-    scheduleRootsUpdate(server) {
-        if (this.rootsUpdateTimeout) {
-            this.rootsUpdateTimeout.refresh();
-            return;
-        }
-        this.rootsUpdateTimeout = setTimeout(() => {
-            this.rootsUpdateTimeout = undefined;
-            void this.updateRootsFromClient(server);
-        }, ROOTS_DEBOUNCE_MS);
-        this.rootsUpdateTimeout.unref();
-    }
-    async recomputeAllowedDirectories() {
-        const cliAllowedDirs = normalizeCLIDirectories(this.options.cliAllowedDirs ?? []);
-        const allowCwd = this.options.allowCwd === true;
-        const allowCwdDirs = allowCwd ? [normalizePath(process.cwd())] : [];
-        const baseline = [...cliAllowedDirs, ...allowCwdDirs];
-        const { signal, cleanup } = createTimedAbortSignal(undefined, ROOTS_TIMEOUT_MS);
-        try {
-            const rootsToInclude = baseline.length > 0
-                ? await filterRootsWithinBaseline(this.rootDirectories, baseline, signal)
-                : this.rootDirectories;
-            const combined = [...baseline, ...rootsToInclude];
-            await setAllowedDirectoriesResolved(combined, signal);
-        }
-        finally {
-            cleanup();
-        }
-    }
-    logMissingDirectories(server) {
-        if (this.options.allowCwd) {
-            logToMcp(server, 'notice', 'No allowed directories specified. Using the current working directory as an allowed directory.', this.loggingState.minimumLevel);
-            return;
-        }
-        logToMcp(server, 'warning', 'No allowed directories specified. Please provide directories as command-line arguments or enable --allow-cwd to use the current working directory.', this.loggingState.minimumLevel);
-    }
-    async updateRootsFromClient(server) {
-        try {
-            const clientCapabilities = server.server.getClientCapabilities();
-            if (!clientCapabilities?.roots) {
-                this.rootDirectories = [];
-                return;
-            }
-            const rootsResult = await server.server.listRoots(undefined, {
-                timeout: ROOTS_TIMEOUT_MS,
-            });
-            const roots = extractRoots(rootsResult);
-            this.rootDirectories = await resolveRootDirectories(roots);
-        }
-        catch (error) {
-            logToMcp(server, 'debug', `[DEBUG] MCP Roots protocol unavailable or failed: ${formatUnknownErrorMessage(error)}`, this.loggingState.minimumLevel);
-        }
-        finally {
-            await this.recomputeAllowedDirectories();
-        }
-    }
-}
-const rootsManagers = new WeakMap();
-function getRootsManager(server) {
-    const manager = rootsManagers.get(server);
-    if (!manager) {
-        throw new Error('Roots manager not initialized for server instance');
-    }
-    return manager;
-}
-const RootSchema = z.strictObject({
-    uri: z.string(),
-    name: z.string().optional(),
-});
-const RootsResponseSchema = z.object({
-    roots: z.array(RootSchema).optional(),
-});
-function extractRoots(value) {
-    const parsed = RootsResponseSchema.safeParse(value);
-    if (!parsed.success || !parsed.data.roots) {
-        return [];
-    }
-    const roots = [];
-    for (const root of parsed.data.roots) {
-        if (isRoot(root)) {
-            roots.push(normalizeRoot(root));
-        }
-    }
-    return roots;
-}
-async function resolveRootDirectories(roots) {
-    if (roots.length === 0)
-        return [];
-    const { signal, cleanup } = createTimedAbortSignal(undefined, ROOTS_TIMEOUT_MS);
-    try {
-        return await getValidRootDirectories(roots, signal);
-    }
-    finally {
-        cleanup();
-    }
-}
-function isRoot(value) {
-    return isRecord(value) && typeof value['uri'] === 'string';
-}
-function normalizeRoot(root) {
-    return root.name ? { uri: root.uri, name: root.name } : { uri: root.uri };
-}
-async function filterRootsWithinBaseline(roots, baseline, signal) {
-    const normalizedBaseline = normalizeCLIDirectories(baseline);
-    const filtered = [];
-    for (const root of roots) {
-        const normalizedRoot = normalizePath(root);
-        const isValid = await isRootWithinBaseline(normalizedRoot, normalizedBaseline, signal);
-        if (isValid)
-            filtered.push(normalizedRoot);
-    }
-    return filtered;
-}
-async function isRootWithinBaseline(normalizedRoot, baseline, signal) {
-    if (!isPathWithinDirectories(normalizedRoot, baseline)) {
-        return false;
-    }
-    try {
-        assertNotAborted(signal);
-        const realPath = await withAbort(fs.realpath(normalizedRoot), signal);
-        const normalizedReal = normalizePath(realPath);
-        return isPathWithinDirectories(normalizedReal, baseline);
-    }
-    catch {
-        return false;
-    }
-}
-async function loadServerInstructions() {
-    const defaultInstructions = `
-Filesystem MCP Instructions
-(Detailed instructions failed to load - check logs)
-`;
-    try {
-        const currentDir = path.dirname(fileURLToPath(import.meta.url));
-        return await fs.readFile(path.join(currentDir, 'instructions.md'), 'utf-8');
-    }
-    catch (error) {
-        console.error('[WARNING] Failed to load instructions.md:', formatUnknownErrorMessage(error));
-        return defaultInstructions;
-    }
-}
-async function getLocalIconInfo() {
-    const name = 'logo.svg';
-    const mime = 'image/svg+xml';
-    try {
-        const iconPath = new URL(`../assets/${name}`, import.meta.url);
-        const buffer = await fs.readFile(iconPath);
-        return {
-            src: `data:${mime};base64,${buffer.toString('base64')}`,
-            mimeType: mime,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function createServer(options = {}) {
-    const resourceStore = createInMemoryResourceStore();
-    const serverInstructions = await loadServerInstructions();
-    const localIcon = await getLocalIconInfo();
-    const taskStore = new InMemoryTaskStore();
-    const taskMessageQueue = new InMemoryTaskMessageQueue();
-    const serverConfig = {
-        capabilities: {
-            logging: {},
-            resources: {},
-            tools: {},
-            prompts: { listChanged: true },
-            completions: {},
-            tasks: {
-                list: {},
-                cancel: {},
-                requests: { tools: { call: {} } },
-            },
-        },
-        taskStore,
-        taskMessageQueue,
-    };
-    if (serverInstructions) {
-        serverConfig.instructions = serverInstructions;
-    }
-    const server = new McpServer(withDefaultIcons({
-        name: 'filesystem-mcp',
-        title: 'Filesystem MCP',
-        version: SERVER_VERSION,
-        ...(SERVER_DESCRIPTION ? { description: SERVER_DESCRIPTION } : {}),
-        ...(SERVER_HOMEPAGE ? { websiteUrl: SERVER_HOMEPAGE } : {}),
-    }, localIcon), serverConfig);
-    const loggingState = {
-        minimumLevel: 'debug',
-    };
-    const rootsManager = new RootsManager(options, loggingState);
-    rootsManagers.set(server, rootsManager);
-    server.server.setRequestHandler(SetLevelRequestSchema, (req) => {
-        loggingState.minimumLevel = req.params.level;
-        return {};
-    });
-    registerInstructionResource(server, serverInstructions, localIcon);
-    registerGetHelpPrompt(server, serverInstructions, localIcon);
-    registerResultResources(server, resourceStore, localIcon);
-    registerCompletions(server);
-    {
-        const stripStructured = process.env['FS_CONTEXT_STRIP_STRUCTURED'] !== '0';
-        if (stripStructured) {
-            const typedServer = server;
-            const origReg = typedServer.registerTool.bind(server);
-            typedServer.registerTool = (...regArgs) => {
-                // Strip outputSchema so SDK won't require structuredContent
-                if (regArgs.length >= 2 &&
-                    regArgs[1] &&
-                    typeof regArgs[1] === 'object') {
-                    const config = { ...regArgs[1] };
-                    delete config['outputSchema'];
-                    regArgs[1] = config;
-                }
-                const handlerIdx = regArgs.length - 1;
-                const origHandler = regArgs[handlerIdx];
-                if (typeof origHandler !== 'function')
-                    return origReg(...regArgs);
-                regArgs[handlerIdx] = async (...hArgs) => {
-                    const r = await origHandler(...hArgs);
-                    if (!r || typeof r !== 'object')
-                        return r;
-                    const record = r;
-                    return Object.fromEntries(Object.entries(record).filter(([key]) => key !== 'structuredContent'));
-                };
-                return origReg(...regArgs);
-            };
-        }
-    }
-    registerAllTools(server, {
-        resourceStore,
-        isInitialized: () => rootsManager.isInitialized(),
-        ...(localIcon ? { iconInfo: localIcon } : {}),
-    });
-    return server;
-}
-export async function startServer(server) {
-    const transport = new StdioServerTransport();
-    const rootsManager = getRootsManager(server);
-    rootsManager.registerHandlers(server);
-    await rootsManager.recomputeAllowedDirectories();
-    await server.connect(transport);
-    rootsManager.logMissingDirectoriesIfNeeded(server);
-}
+export { createServer, startServer } from './server/bootstrap.js';

package/dist/tools/apply-patch.js

@@ -6,7 +6,7 @@ import { ErrorCode, McpError } from '../lib/errors.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
 import { ApplyPatchInputSchema, ApplyPatchOutputSchema } 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 APPLY_PATCH_TOOL = {
     title: 'Apply Patch',
@@ -69,11 +69,25 @@ export function registerApplyPatchTool(server, options = {}) {
         run: (signal) => handleApplyPatch(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(ApplyPatchInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         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

@@ -9,7 +9,7 @@ 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, CalculateHashOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const WINDOWS_PATH_SEPARATOR = /\\/gu;
 const CALCULATE_HASH_TOOL = {
@@ -153,24 +153,59 @@ 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),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(CalculateHashInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
     });
     if (registerToolTaskIfAvailable(server, 'calculate_hash', CALCULATE_HASH_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))

package/dist/tools/create-directory.js

@@ -4,7 +4,7 @@ import { ErrorCode } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/path-validation.js';
 import { CreateDirectoryInputSchema, CreateDirectoryOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, IDEMPOTENT_WRITE_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, IDEMPOTENT_WRITE_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const CREATE_DIRECTORY_TOOL = {
     title: 'Create Directory',
@@ -30,9 +30,19 @@ export function registerCreateDirectoryTool(server, options = {}) {
         run: (signal) => handleCreateDirectory(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(CreateDirectoryInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         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

@@ -4,7 +4,7 @@ import { ErrorCode, isNodeError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/path-validation.js';
 import { DeleteFileInputSchema, DeleteFileOutputSchema } 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 DELETE_FILE_TOOL = {
     title: 'Delete File',
@@ -74,9 +74,16 @@ export function registerDeleteFileTool(server, options = {}) {
             return buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path);
         },
     });
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(DeleteFileInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🛠 rm: ${path.basename(args.path)}`,
+        completionMessage: (args, result) => {
+            const name = path.basename(args.path);
+            if (result.isError)
+                return `🛠 rm: ${name} • failed`;
+            return `🛠 rm: ${name} • deleted`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'rm', DELETE_FILE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/dist/tools/diff-files.js

@@ -6,7 +6,7 @@ import { ErrorCode, McpError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
 import { DiffFilesInputSchema, DiffFilesOutputSchema } from '../schemas.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 const DIFF_FILES_TOOL = {
     title: 'Diff Files',
     description: 'Generate a unified diff between two files. ' +
@@ -80,12 +80,26 @@ export function registerDiffFilesTool(server, options = {}) {
         run: (signal) => handleDiffFiles(args, signal, options.resourceStore),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.original),
     });
-    server.registerTool('diff_files', withDefaultIcons({ ...DIFF_FILES_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(DiffFilesInputSchema, handler);
+    server.registerTool('diff_files', withDefaultIcons({ ...DIFF_FILES_TOOL }, options.iconInfo), wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
             const name1 = path.basename(args.original);
             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

@@ -4,7 +4,7 @@ import { ErrorCode } from '../lib/errors.js';
 import { atomicWriteFile } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
 import { EditFileInputSchema, EditFileOutputSchema } 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';
 const EDIT_FILE_TOOL = {
     title: 'Edit File',
     description: 'Edit a file by replacing text. Sequentially applies a list of string replacements. ' +
@@ -79,23 +79,24 @@ export function registerEditFileTool(server, options = {}) {
         run: (signal) => handleEditFile(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
     });
-    server.registerTool('edit', withDefaultIcons({ ...EDIT_FILE_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(EditFileInputSchema, handler);
+    server.registerTool('edit', withDefaultIcons({ ...EDIT_FILE_TOOL }, options.iconInfo), wrapToolHandler(validatedHandler, {
         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

@@ -4,7 +4,7 @@ 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, ListDirectoryOutputSchema, } 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';
 const LIST_DIRECTORY_TOOL = {
     title: 'List Directory',
     description: 'List the immediate contents of a directory (non-recursive). ' +
@@ -96,7 +96,8 @@ export function registerListDirectoryTool(server, options = {}) {
         run: (signal) => handleListDirectory(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, args.path ?? '.'),
     });
-    server.registerTool('ls', withDefaultIcons({ ...LIST_DIRECTORY_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(ListDirectoryInputSchema, handler);
+    server.registerTool('ls', withDefaultIcons({ ...LIST_DIRECTORY_TOOL }, options.iconInfo), wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
             if (args.path) {
@@ -104,5 +105,15 @@ export function registerListDirectoryTool(server, options = {}) {
             }
             return '≣ ls';
         },
+        completionMessage: (args, result) => {
+            const base = args.path ? path.basename(args.path) : '.';
+            if (result.isError)
+                return `≣ ls: ${base} • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `≣ ls: ${base} • failed`;
+            const count = sc.totalEntries ?? 0;
+            return `≣ ls: ${base} • ${count} ${count === 1 ? 'entry' : 'entries'}`;
+        },
     }));
 }

package/dist/tools/move-file.js

@@ -4,7 +4,7 @@ import { ErrorCode, isNodeError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath, validatePathForWrite, } from '../lib/path-validation.js';
 import { MoveFileInputSchema, MoveFileOutputSchema } 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 MOVE_FILE_TOOL = {
     title: 'Move File',
@@ -46,9 +46,17 @@ export function registerMoveFileTool(server, options = {}) {
         run: (signal) => handleMoveFile(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.source),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(MoveFileInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         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)}`,
+        completionMessage: (args, result) => {
+            const src = path.basename(args.source);
+            const dst = path.basename(args.destination);
+            if (result.isError)
+                return `🛠 mv: ${src} → ${dst} • failed`;
+            return `🛠 mv: ${src} → ${dst} • moved`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'mv', MOVE_FILE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;