@j0hanz/filesystem-mcp 1.2.2 → 1.2.3

package/dist/server.js

@@ -1,317 +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);
-    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,7 +69,8 @@ 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);

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 = {
@@ -204,7 +204,8 @@ export function registerCalculateHashTool(server, options = {}) {
         },
         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,7 +30,8 @@ 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) => {
             const name = path.basename(args.path) || args.path;

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,7 +80,8 @@ 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);

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,7 +79,8 @@ 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);
@@ -88,10 +89,10 @@ export function registerEditFileTool(server, options = {}) {
         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]}]`;
             }

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;

package/dist/tools/read-multiple.js

@@ -3,7 +3,7 @@ import { DEFAULT_READ_MANY_MAX_TOTAL_SIZE, DEFAULT_SEARCH_TIMEOUT_MS, } from '..
 import { ErrorCode } from '../lib/errors.js';
 import { readMultipleFiles } from '../lib/file-operations/read-multiple-files.js';
 import { ReadMultipleFilesInputSchema, ReadMultipleFilesOutputSchema, } 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';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const READ_MULTIPLE_FILES_TOOL = {
     title: 'Read Multiple Files',
@@ -121,19 +121,20 @@ export function registerReadMultipleFilesTool(server, options = {}) {
             onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FILE, primaryPath),
         });
     };
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(ReadMultipleFilesInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
             const first = path.basename(args.paths[0] ?? '');
             const extra = args.paths.length > 1 ? `, ${path.basename(args.paths[1] ?? '')}…` : '';
             return `🕮 read_many: ${args.paths.length} files [${first}${extra}]`;
         },
-        completionMessage: (_args, result) => {
+        completionMessage: (args, result) => {
             if (result.isError)
-                return `🕮 read_many • failed`;
+                return `🕮 read_many: ${args.paths.length} files • failed`;
             const sc = result.structuredContent;
             if (!sc.ok)
-                return `🕮 read_many • failed`;
+                return `🕮 read_many: ${args.paths.length} files • failed`;
             const total = sc.summary?.total ?? 0;
             const succeeded = sc.summary?.succeeded ?? 0;
             const failed = sc.summary?.failed ?? 0;

package/dist/tools/read.js

@@ -3,7 +3,7 @@ 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, wrapToolHandler, } from './shared.js';
+import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const READ_FILE_TOOL = {
     title: 'Read File',
@@ -80,7 +80,8 @@ export function registerReadFileTool(server, options = {}) {
         run: (signal) => handleReadFile(args, signal, options.resourceStore),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FILE, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(ReadFileInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
             const name = path.basename(args.path);

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

@@ -8,7 +8,7 @@ import { globEntries } from '../lib/file-operations/glob-engine.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { validateExistingPath, validatePathForWrite, } from '../lib/path-validation.js';
 import { SearchAndReplaceInputSchema, SearchAndReplaceOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createProgressReporter, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, notifyProgress, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, createProgressReporter, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, notifyProgress, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const SEARCH_AND_REPLACE_TOOL = {
     title: 'Search and Replace',
@@ -279,7 +279,8 @@ export function registerSearchAndReplaceTool(server, options = {}) {
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
     });
     const { isInitialized } = options;
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(SearchAndReplaceInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: isInitialized,
     });
     if (registerToolTaskIfAvailable(server, 'search_and_replace', SEARCH_AND_REPLACE_TOOL, wrappedHandler, options.iconInfo, isInitialized))

package/dist/tools/roots.js

@@ -2,7 +2,7 @@ import { joinLines } from '../config.js';
 import { ErrorCode } from '../lib/errors.js';
 import { getAllowedDirectories } from '../lib/path-validation.js';
 import { ListAllowedDirectoriesInputSchema, ListAllowedDirectoriesOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 const LIST_ALLOWED_DIRECTORIES_TOOL = {
     title: 'Workspace Roots',
     description: 'List the workspace roots this server can access. ' +
@@ -38,8 +38,18 @@ export function registerListAllowedDirectoriesTool(server, options = {}) {
         run: () => handleListAllowedDirectories(),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN),
     });
-    server.registerTool('roots', withDefaultIcons({ ...LIST_ALLOWED_DIRECTORIES_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(ListAllowedDirectoriesInputSchema, handler);
+    server.registerTool('roots', withDefaultIcons({ ...LIST_ALLOWED_DIRECTORIES_TOOL }, options.iconInfo), wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: () => '≣ roots',
+        completionMessage: (_args, result) => {
+            if (result.isError)
+                return `≣ roots • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `≣ roots • failed`;
+            const count = sc.rootsCount ?? 0;
+            return `≣ roots • ${count} ${count === 1 ? 'root' : 'roots'}`;
+        },
     }));
 }