@j0hanz/filesystem-mcp 1.9.0 → 1.10.0

package/dist/server/roots-manager.js

@@ -3,7 +3,7 @@ import { InitializedNotificationSchema, RootsListChangedNotificationSchema, } fr
 import { z } from 'zod';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
-import { getAllowedDirectories, getValidRootDirectories, isPathWithinDirectories, normalizePath, setAllowedDirectoriesResolved, } from '../lib/paths.js';
+import { getValidRootDirectories, isPathWithinDirectories, normalizePath, resolveAllowedDirectoriesState, setAllowedDirectoriesStateResolved, } from '../lib/paths.js';
 import { isRecord } from '../lib/utils.js';
 import { logToMcp } from './bootstrap.js';
 const ROOTS_TIMEOUT_MS = 5000;
@@ -83,6 +83,10 @@ async function filterRootsWithinBaseline(roots, baseline, signal) {
 export class RootsManager {
     rootsUpdateTimeout;
     rootDirectories = [];
+    allowedDirectoriesState = {
+        primary: [],
+        expanded: [],
+    };
     clientInitialized = false;
     // Set to true when an update is in progress, to prevent concurrent executions. If a change arrives while true, we queue a single retry after completion to ensure the last-known state is applied. This
     updatingRoots = false;
@@ -103,8 +107,14 @@ export class RootsManager {
             this.rootsUpdateTimeout = undefined;
         }
     }
+    getAllowedDirectoriesState() {
+        return {
+            primary: [...this.allowedDirectoriesState.primary],
+            expanded: [...this.allowedDirectoriesState.expanded],
+        };
+    }
     logMissingDirectoriesIfNeeded(server) {
-        if (getAllowedDirectories().length === 0) {
+        if (this.allowedDirectoriesState.expanded.length === 0) {
             this.logMissingDirectories(server);
         }
     }
@@ -130,7 +140,9 @@ export class RootsManager {
                 ? await filterRootsWithinBaseline(this.rootDirectories, baseline, signal)
                 : this.rootDirectories;
             const combined = [...baseline, ...rootsToInclude];
-            await setAllowedDirectoriesResolved(combined, signal);
+            const nextState = await resolveAllowedDirectoriesState(combined, signal);
+            this.allowedDirectoriesState = nextState;
+            setAllowedDirectoriesStateResolved(nextState);
         }
         finally {
             cleanup();

package/dist/tools/apply-patch.js

@@ -1,8 +1,8 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { applyPatch } from 'diff';
+import { applyPatch, parsePatch } from 'diff';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
-import { ErrorCode, McpError } from '../lib/errors.js';
+import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
@@ -11,13 +11,18 @@ import { registerToolTaskIfAvailable } from './task-support.js';
 export const APPLY_PATCH_TOOL = {
     name: 'apply_patch',
     title: 'Apply Patch',
-    description: 'Apply a unified diff patch to a file. ' +
+    description: 'Apply a unified diff patch to one or more files. ' +
+        'Single-file: throws on failure. Multi-file: best-effort per file with `results[]`. ' +
         'Workflow: `diff_files` \u2192 `apply_patch(dryRun:true)` \u2192 `apply_patch`. ' +
         'On failure, regenerate the patch from current file content.',
     inputSchema: ApplyPatchInputSchema,
     outputSchema: ApplyPatchOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
+    nuances: [
+        'Multi-file patches use `path` as base directory; per-file results in `results[]`.',
+    ],
     gotchas: ['Patch must include valid hunk headers; use `dryRun=true` first.'],
+    taskSupport: 'optional',
 };
 function assertPatchTargetSizeWithinLimit(filePath, size, maxFileSize) {
     if (size <= maxFileSize)
@@ -33,37 +38,138 @@ function assertPatchHasHunks(patch) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch must include unified hunk headers (e.g., @@ -1,2 +1,2 @@).');
     }
 }
-async function handleApplyPatch(args, signal) {
-    const maxFileSize = MAX_TEXT_FILE_SIZE;
-    const validPath = await validateExistingPath(args.path, signal);
-    assertAllowedFileAccess(args.path, validPath);
+function countStructuredPatchStats(diff) {
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    for (const hunk of diff.hunks) {
+        for (const line of hunk.lines) {
+            if (line.startsWith('+'))
+                linesAdded++;
+            else if (line.startsWith('-'))
+                linesRemoved++;
+        }
+    }
+    return { hunksApplied: diff.hunks.length, linesAdded, linesRemoved };
+}
+function stripGitPrefix(fileName) {
+    return fileName.startsWith('a/') || fileName.startsWith('b/')
+        ? fileName.slice(2)
+        : fileName;
+}
+function extractPatchTargetPath(diff) {
+    if (diff.newFileName)
+        return stripGitPrefix(diff.newFileName);
+    if (diff.oldFileName)
+        return stripGitPrefix(diff.oldFileName);
+    return undefined;
+}
+async function applyPatchToFile(filePath, diff, options, signal) {
+    const validPath = await validateExistingPath(filePath, signal);
+    assertAllowedFileAccess(filePath, validPath);
     const stats = await withAbort(fs.stat(validPath), signal);
-    assertPatchTargetSizeWithinLimit(validPath, stats.size, maxFileSize);
+    assertPatchTargetSizeWithinLimit(validPath, stats.size, MAX_TEXT_FILE_SIZE);
     const content = await fs.readFile(validPath, { encoding: 'utf-8', signal });
-    const fuzzFactor = args.fuzzFactor ?? 0;
-    assertPatchHasHunks(args.patch);
-    const patched = applyPatch(content, args.patch, {
-        fuzzFactor,
-        autoConvertLineEndings: args.autoConvertLineEndings,
+    const patched = applyPatch(content, diff, {
+        fuzzFactor: options.fuzzFactor,
+        autoConvertLineEndings: options.autoConvertLineEndings,
     });
     if (patched === false) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch application failed. The file content may have changed or patch context is insufficient. Generate a fresh patch via diff_files against the current file, then retry. If differences are minor, enable fuzzy matching with the fuzzFactor parameter.');
+        return {
+            path: validPath,
+            applied: false,
+            error: 'Patch application failed',
+        };
     }
     if (patched === content) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch had no effect — the file content is unchanged after applying. The patch may not match the current file content. Generate a fresh patch via diff_files and retry.');
+        return { path: validPath, applied: false, error: 'Patch had no effect' };
     }
-    if (args.dryRun) {
-        return buildToolResponse('Dry run successful. Patch can be applied.', {
-            ok: true,
-            path: validPath,
-            applied: true,
-        });
+    const patchStats = countStructuredPatchStats(diff);
+    if (!options.dryRun) {
+        await atomicWriteFile(validPath, patched, { encoding: 'utf-8', signal });
+    }
+    return { path: validPath, applied: true, ...patchStats };
+}
+async function handleMultiFilePatch(basePath, parsed, options, signal) {
+    const validBase = await validateExistingPath(basePath, signal);
+    const results = [];
+    for (const diff of parsed) {
+        const fileName = extractPatchTargetPath(diff);
+        if (!fileName) {
+            results.push({
+                path: '<unknown>',
+                applied: false,
+                error: 'Missing file name in patch header',
+            });
+            continue;
+        }
+        const filePath = path.resolve(validBase, fileName);
+        try {
+            const result = await applyPatchToFile(filePath, diff, options, signal);
+            results.push({ ...result, path: fileName });
+        }
+        catch (error) {
+            results.push({
+                path: fileName,
+                applied: false,
+                error: formatUnknownErrorMessage(error),
+            });
+        }
+    }
+    const totals = results.reduce((acc, r) => {
+        if (r.applied) {
+            acc.applied++;
+            acc.hunks += r.hunksApplied ?? 0;
+            acc.added += r.linesAdded ?? 0;
+            acc.removed += r.linesRemoved ?? 0;
+        }
+        return acc;
+    }, { applied: 0, hunks: 0, added: 0, removed: 0 });
+    const label = options.dryRun ? ' (dry run)' : '';
+    const text = `Applied ${totals.applied}/${parsed.length} file patches${label}`;
+    return buildToolResponse(text, {
+        ok: totals.applied === parsed.length,
+        path: basePath,
+        applied: totals.applied > 0,
+        hunksApplied: totals.hunks,
+        linesAdded: totals.added,
+        linesRemoved: totals.removed,
+        results,
+    });
+}
+async function handleApplyPatch(args, signal) {
+    assertPatchHasHunks(args.patch);
+    const fuzzFactor = args.fuzzFactor ?? 0;
+    const parsed = parsePatch(args.patch);
+    const options = {
+        dryRun: args.dryRun,
+        fuzzFactor,
+        autoConvertLineEndings: args.autoConvertLineEndings,
+    };
+    // Multi-file patch: best-effort per file
+    if (parsed.length > 1) {
+        return handleMultiFilePatch(args.path, parsed, options, signal);
+    }
+    // Single-file patch: delegate to shared helper, then assert success
+    const diff = parsed[0];
+    if (!diff) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'No patch content found.');
+    }
+    const result = await applyPatchToFile(args.path, diff, options, signal);
+    if (!result.applied) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, result.error === 'Patch had no effect'
+            ? 'Patch had no effect \u2014 the file content is unchanged after applying. The patch may not match the current file content. Generate a fresh patch via diff_files and retry.'
+            : 'Patch application failed. The file content may have changed or patch context is insufficient. Generate a fresh patch via diff_files against the current file, then retry. If differences are minor, enable fuzzy matching with the fuzzFactor parameter.');
     }
-    await atomicWriteFile(validPath, patched, { encoding: 'utf-8', signal });
-    return buildToolResponse(`Successfully patched ${args.path}`, {
+    const text = args.dryRun
+        ? 'Dry run successful. Patch can be applied.'
+        : `Successfully patched ${args.path}`;
+    return buildToolResponse(text, {
         ok: true,
-        path: validPath,
+        path: result.path,
         applied: true,
+        hunksApplied: result.hunksApplied,
+        linesAdded: result.linesAdded,
+        linesRemoved: result.linesRemoved,
     });
 }
 export function registerApplyPatchTool(server, options = {}) {
@@ -79,20 +185,18 @@ export function registerApplyPatchTool(server, options = {}) {
         guard: options.isInitialized,
         progressMessage: (args) => {
             const name = path.basename(args.path);
-            return args.dryRun
-                ? `🛠 apply_patch: ${name} [dry run]`
-                : `🛠 apply_patch: ${name}`;
+            return args.dryRun ? `🛠 patch: ${name} [dry run]` : `🛠 patch: ${name}`;
         },
         completionMessage: (args, result) => {
             const name = path.basename(args.path);
             if (result.isError)
-                return `🛠 apply_patch: ${name} • failed`;
+                return `🛠 patch: ${name} • failed`;
             const sc = result.structuredContent;
             if (!sc.ok)
-                return `🛠 apply_patch: ${name} • failed`;
+                return `🛠 patch: ${name} • failed`;
             if (args.dryRun)
-                return `🛠 apply_patch: ${name} • dry run OK`;
-            return `🛠 apply_patch: ${name} • applied`;
+                return `🛠 patch: ${name} • dry run OK`;
+            return `🛠 patch: ${name} • applied`;
         },
     });
     const validatedHandler = withValidatedArgs(ApplyPatchInputSchema, wrappedHandler);

package/dist/tools/calculate-hash.js

@@ -23,6 +23,7 @@ export const CALCULATE_HASH_TOOL = {
     nuances: [
         'Directory hashing respects root `.gitignore` and sorts paths for stable output.',
     ],
+    taskSupport: 'optional',
 };
 async function hashFile(filePath, encoding, signal) {
     assertNotAborted(signal);
@@ -87,6 +88,7 @@ async function hashDirectory(dirPath, options = {}) {
     const concurrency = Math.min(PARALLEL_CONCURRENCY, 8);
     const entries = [];
     let filesHashed = 0;
+    const totalFiles = filteredPaths.length;
     for (let i = 0; i < filteredPaths.length; i += concurrency) {
         assertNotAborted(signal);
         const batch = filteredPaths.slice(i, i + concurrency);
@@ -96,10 +98,14 @@ async function hashDirectory(dirPath, options = {}) {
         }));
         entries.push(...batchResults);
         filesHashed += batchResults.length;
-        reportPeriodicProgress(onProgress, filesHashed, { throttleModulo: 25 });
+        reportPeriodicProgress(onProgress, filesHashed, {
+            throttleModulo: 25,
+            total: totalFiles,
+        });
     }
     reportPeriodicProgress(onProgress, filesHashed, {
         throttleModulo: 25,
+        total: totalFiles,
         force: true,
     });
     assertNotAborted(signal);
@@ -158,13 +164,12 @@ export function registerCalculateHashTool(server, options = {}) {
         context: { path: args.path },
         run: async (signal) => {
             const baseName = path.basename(args.path);
-            const progress = createToolProgressSession(extra, `🕮 calculate_hash: ${baseName}`);
+            const progress = createToolProgressSession(extra, `🕮 hash: ${baseName}`);
             const progressWithMessage = ({ current, total, }) => {
-                const fileWord = current === 1 ? 'file' : 'files';
                 progress.update({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🕮 calculate_hash: ${baseName} [${current} ${fileWord} hashed]`,
+                    message: `🕮 hash: ${baseName} [${current} files]`,
                 });
             };
             try {
@@ -177,16 +182,16 @@ export function registerCalculateHashTool(server, options = {}) {
                     suffix = 'failed';
                 }
                 else if (sc.fileCount !== undefined && sc.fileCount > 1) {
-                    suffix = `${sc.fileCount} files • ${(sc.hash ?? '').slice(0, 8)}...`;
+                    suffix = `${sc.fileCount} files • ${(sc.hash ?? '').slice(0, 8)}…`;
                 }
                 else {
-                    suffix = `${(sc.hash ?? '').slice(0, 8)}...`;
+                    suffix = `${(sc.hash ?? '').slice(0, 8)}…`;
                 }
-                progress.complete(`🕮 calculate_hash: ${baseName} • ${suffix}`, finalCurrent);
+                progress.complete(`🕮 hash: ${baseName} • ${suffix}`, finalCurrent);
                 return result;
             }
             catch (error) {
-                progress.fail(`🕮 calculate_hash: ${baseName} • failed`);
+                progress.fail(`🕮 hash: ${baseName} • failed`);
                 throw error;
             }
         },

package/dist/tools/create-directory.js

@@ -1,4 +1,5 @@
 import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/paths.js';
@@ -13,6 +14,7 @@ export const CREATE_DIRECTORY_TOOL = {
     outputSchema: CreateDirectoryOutputSchema,
     annotations: IDEMPOTENT_WRITE_TOOL_ANNOTATIONS,
     nuances: ['Succeeds silently if the directory already exists (idempotent).'],
+    taskSupport: 'optional',
 };
 export async function handleCreateDirectory(args, signal) {
     const allPaths = [];
@@ -42,14 +44,23 @@ export function registerCreateDirectoryTool(server, options = {}) {
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
+            if (args.path && !args.paths?.length) {
+                return `🛠 mkdir: ${path.basename(args.path)}`;
+            }
             const count = (args.path ? 1 : 0) + (args.paths?.length ?? 0);
-            return `🛠 mkdir: ${count} director${count === 1 ? 'y' : 'ies'}`;
+            return `🛠 mkdir: ${count} directories`;
         },
         completionMessage: (args, result) => {
+            if (args.path && !args.paths?.length) {
+                const name = path.basename(args.path);
+                if (result.isError)
+                    return `🛠 mkdir: ${name} • failed`;
+                return `🛠 mkdir: ${name} • created`;
+            }
             const count = (args.path ? 1 : 0) + (args.paths?.length ?? 0);
             if (result.isError)
-                return `🛠 mkdir: ${count} • failed`;
-            return `🛠 mkdir: ${count} • created`;
+                return `🛠 mkdir: ${count} directories • failed`;
+            return `🛠 mkdir: ${count} directories • created`;
         },
     });
     const validatedHandler = withValidatedArgs(CreateDirectoryInputSchema, wrappedHandler);

package/dist/tools/delete-file.js

@@ -17,6 +17,7 @@ export const DELETE_FILE_TOOL = {
         'No undo — deletion is permanent.',
         'Non-empty directories require `recursive=true`.',
     ],
+    taskSupport: 'optional',
 };
 async function handleDeleteFile(args, signal) {
     const validPath = await validatePathForWrite(args.path, signal);

package/dist/tools/diff-files.js

@@ -18,7 +18,22 @@ export const DIFF_FILES_TOOL = {
     outputSchema: DiffFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
     gotchas: ['`isIdentical=true` means no hunks (`@@`) and empty diff.'],
+    taskSupport: 'optional',
 };
+function computeDiffStats(patch) {
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    let hunksCount = 0;
+    for (const line of patch.split('\n')) {
+        if (line.startsWith('@@'))
+            hunksCount++;
+        else if (line.startsWith('+') && !line.startsWith('+++'))
+            linesAdded++;
+        else if (line.startsWith('-') && !line.startsWith('---'))
+            linesRemoved++;
+    }
+    return { linesAdded, linesRemoved, hunksCount };
+}
 function assertDiffFileSizeWithinLimit(filePath, size, maxFileSize) {
     if (size <= maxFileSize)
         return;
@@ -47,6 +62,7 @@ async function handleDiffFiles(args, signal, resourceStore) {
     });
     const isIdentical = !patch.includes('@@');
     const diffText = isIdentical ? '' : patch;
+    const stats = isIdentical ? undefined : computeDiffStats(patch);
     const externalized = maybeExternalizeTextContent(resourceStore, diffText, {
         name: 'diff:patch',
         mimeType: 'text/x-diff',
@@ -56,6 +72,7 @@ async function handleDiffFiles(args, signal, resourceStore) {
             ok: true,
             diff: diffText,
             isIdentical,
+            ...(stats ?? {}),
         });
     }
     const { preview, entry } = externalized;
@@ -63,6 +80,7 @@ async function handleDiffFiles(args, signal, resourceStore) {
         ok: true,
         diff: preview,
         isIdentical,
+        ...(stats ?? {}),
         truncated: true,
         resourceUri: entry.uri,
     }, [
@@ -71,6 +89,7 @@ async function handleDiffFiles(args, signal, resourceStore) {
             name: entry.name,
             mimeType: entry.mimeType,
             description: 'Full diff content',
+            expiresAt: entry.expiresAt,
         }),
     ]);
 }
@@ -86,22 +105,21 @@ export function registerDiffFilesTool(server, options = {}) {
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
-            const name1 = path.basename(args.original);
-            const name2 = path.basename(args.modified);
-            return `🕮 diff_files: ${name1} ⟷ ${name2}`;
+            const n1 = path.basename(args.original);
+            const n2 = path.basename(args.modified);
+            return `🕮 diff: ${n1} ⟷ ${n2}`;
         },
         completionMessage: (args, result) => {
             const n1 = path.basename(args.original);
             const n2 = path.basename(args.modified);
             if (result.isError)
-                return `🕮 diff_files: ${n1} ⟷ ${n2} • failed`;
+                return `🕮 diff: ${n1} ⟷ ${n2} • failed`;
             const sc = result.structuredContent;
             if (!sc.ok)
-                return `🕮 diff_files: ${n1} ⟷ ${n2} • failed`;
+                return `🕮 diff: ${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' : ''}`;
+                return `🕮 diff: ${n1} ⟷ ${n2} • identical`;
+            return `🕮 diff: ${n1} ⟷ ${n2} • changed`;
         },
     });
     const validatedHandler = withValidatedArgs(DiffFilesInputSchema, wrappedHandler);

package/dist/tools/edit-file.js

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { createTwoFilesPatch } from 'diff';
 import RE2 from 're2';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
@@ -19,6 +20,7 @@ export const EDIT_FILE_TOOL = {
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
     nuances: ['Each edit applies to the output of the previous edit.'],
     gotchas: ['Unmatched `oldText` entries listed in `unmatchedEdits`.'],
+    taskSupport: 'optional',
 };
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -99,6 +101,9 @@ export async function handleEditFile(args, signal) {
         ...(lineRange ? { lineRange } : {}),
     };
     if (args.dryRun) {
+        if (appliedEdits > 0) {
+            structured.diff = createTwoFilesPatch(path.basename(validPath), path.basename(validPath), content, newContent, 'Original', 'Modified');
+        }
         return buildToolResponse(`Dry run complete. ${appliedEdits} edits would be applied.`, structured);
     }
     if (appliedEdits > 0) {
@@ -127,8 +132,9 @@ export function registerEditFileTool(server, options = {}) {
         guard: options.isInitialized,
         progressMessage: (args) => {
             const name = path.basename(args.path);
-            const dryTag = args.dryRun ? ' [dry run]' : '';
-            return `🛠 edit: ${name} [${args.edits.length} edits]${dryTag}`;
+            const count = args.edits.length;
+            const tag = args.dryRun ? ' [dry run]' : '';
+            return `🛠 edit: ${name} [${count} ${count === 1 ? 'edit' : 'edits'}]${tag}`;
         },
         completionMessage: (args, result) => {
             const name = path.basename(args.path);
@@ -139,14 +145,11 @@ export function registerEditFileTool(server, options = {}) {
                 return `🛠 edit: ${name} • failed`;
             const applied = sc.appliedEdits ?? 0;
             const unmatched = sc.unmatchedEdits?.length ?? 0;
-            const dryPrefix = args.dryRun ? 'dry run — ' : '';
+            const dry = args.dryRun ? 'dry run — ' : '';
             if (unmatched > 0) {
-                return `🛠 edit: ${name} • ${dryPrefix}${applied} applied, ${unmatched} unmatched`;
-            }
-            if (sc.lineRange) {
-                return `🛠 edit: ${name} • ${dryPrefix}lines ${sc.lineRange[0]}–${sc.lineRange[1]}`;
+                return `🛠 edit: ${name} • ${dry}${applied} applied, ${unmatched} unmatched`;
             }
-            return `🛠 edit: ${name} • ${dryPrefix}${applied} applied`;
+            return `🛠 edit: ${name} • ${dry}${applied} applied`;
         },
     });
     const validatedHandler = withValidatedArgs(EditFileInputSchema, wrappedHandler);

package/dist/tools/list-directory.js

@@ -112,12 +112,7 @@ export function registerListDirectoryTool(server, options = {}) {
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
-        progressMessage: (args) => {
-            if (args.path) {
-                return `≣ ls: ${path.basename(args.path)}`;
-            }
-            return '≣ ls';
-        },
+        progressMessage: (args) => `≣ ls: ${args.path ? path.basename(args.path) : '.'}`,
         completionMessage: (args, result) => {
             const base = args.path ? path.basename(args.path) : '.';
             if (result.isError)

package/dist/tools/move-file.js

@@ -17,6 +17,7 @@ export const MOVE_FILE_TOOL = {
     gotchas: [
         'On POSIX, an existing destination is silently overwritten; on Windows, rename fails with EEXIST if destination exists.',
     ],
+    taskSupport: 'optional',
 };
 export async function handleMoveFile(args, signal) {
     const sources = args.sources ?? (args.source ? [args.source] : []);
@@ -82,14 +83,36 @@ export async function handleMoveFile(args, signal) {
                 // Cross-device link, fallback to copy + delete
                 try {
                     await withAbort(fs.cp(validSource, targetPath, { recursive: true }), signal);
-                    await withAbort(fs.rm(validSource, { recursive: true, force: true }), signal);
-                    movedSources.push(validSource);
                 }
                 catch (copyError) {
                     failed.push({
                         source: src,
                         error: formatUnknownErrorMessage(copyError),
                     });
+                    continue;
+                }
+                // Copy succeeded — now remove source
+                try {
+                    await withAbort(fs.rm(validSource, { recursive: true, force: true }), signal);
+                    movedSources.push(validSource);
+                }
+                catch (deleteError) {
+                    // Source delete failed after copy — rollback by removing the copy
+                    try {
+                        await fs.rm(targetPath, { recursive: true, force: true });
+                    }
+                    catch {
+                        // Rollback failed — data exists in both locations
+                        failed.push({
+                            source: src,
+                            error: `Cross-device move partially failed: data exists at both '${validSource}' and '${targetPath}'. ${formatUnknownErrorMessage(deleteError)}`,
+                        });
+                        continue;
+                    }
+                    failed.push({
+                        source: src,
+                        error: `Cross-device move failed: could not remove source. ${formatUnknownErrorMessage(deleteError)}`,
+                    });
                 }
             }
             else {
@@ -122,16 +145,25 @@ export function registerMoveFileTool(server, options = {}) {
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
-            const count = (args.source ? 1 : 0) + (args.sources?.length ?? 0);
             const dest = path.basename(args.destination);
-            return `🛠 mv: ${count} item${count === 1 ? '' : 's'} → ${dest}`;
+            if (args.source && !args.sources?.length) {
+                return `🛠 mv: ${path.basename(args.source)} → ${dest}`;
+            }
+            const count = (args.source ? 1 : 0) + (args.sources?.length ?? 0);
+            return `🛠 mv: ${count} items → ${dest}`;
         },
         completionMessage: (args, result) => {
-            const count = (args.source ? 1 : 0) + (args.sources?.length ?? 0);
             const dest = path.basename(args.destination);
+            if (args.source && !args.sources?.length) {
+                const src = path.basename(args.source);
+                if (result.isError)
+                    return `🛠 mv: ${src} → ${dest} • failed`;
+                return `🛠 mv: ${src} → ${dest} • moved`;
+            }
+            const count = (args.source ? 1 : 0) + (args.sources?.length ?? 0);
             if (result.isError)
-                return `🛠 mv: ${count} → ${dest} • failed`;
-            return `🛠 mv: ${count} → ${dest} • moved`;
+                return `🛠 mv: ${count} items → ${dest} • failed`;
+            return `🛠 mv: ${count} items → ${dest} • moved`;
         },
     });
     const validatedHandler = withValidatedArgs(MoveFileInputSchema, wrappedHandler);

package/dist/tools/read-multiple.js

@@ -16,7 +16,7 @@ export const READ_MULTIPLE_FILES_TOOL = {
     taskSupport: 'optional',
     nuances: ['Total read budget is capped by `MAX_READ_MANY_TOTAL_SIZE`.'],
     gotchas: [
-        'Per-file `truncationReason` can be `head`, `range`, or `externalized`.',
+        'Per-file `truncationReason` can be `head`, `tail`, `range`, or `externalized`.',
     ],
 };
 function toStructuredReadManyResult(result) {
@@ -31,6 +31,8 @@ function toStructuredReadManyResult(result) {
         structured.resourceUri = result.resourceUri;
     if (result.head !== undefined)
         structured.head = result.head;
+    if (result.tail !== undefined)
+        structured.tail = result.tail;
     if (result.startLine !== undefined)
         structured.startLine = result.startLine;
     if (result.endLine !== undefined)
@@ -39,6 +41,8 @@ function toStructuredReadManyResult(result) {
         structured.hasMoreLines = result.hasMoreLines;
     if (result.totalLines !== undefined)
         structured.totalLines = result.totalLines;
+    if (result.linesRead !== undefined)
+        structured.linesRead = result.linesRead;
     if (result.truncationReason) {
         structured.truncationReason = result.truncationReason;
     }
@@ -50,6 +54,7 @@ async function handleReadMultipleFiles(args, signal, resourceStore, onReadComple
     const options = {
         ...(signal ? { signal } : {}),
         ...(args.head !== undefined ? { head: args.head } : {}),
+        ...(args.tail !== undefined ? { tail: args.tail } : {}),
         ...(args.startLine !== undefined ? { startLine: args.startLine } : {}),
         ...(args.endLine !== undefined ? { endLine: args.endLine } : {}),
         ...(onReadComplete ? { onReadComplete } : {}),
@@ -61,6 +66,9 @@ async function handleReadMultipleFiles(args, signal, resourceStore, onReadComple
         if (result.truncated && result.readMode === 'head') {
             baseTruncationReason = 'head';
         }
+        else if (result.truncated && result.readMode === 'tail') {
+            baseTruncationReason = 'tail';
+        }
         else if (result.truncated && result.readMode === 'range') {
             baseTruncationReason = 'range';
         }