@j0hanz/filesystem-mcp 1.13.2 → 1.14.1

package/dist/tools/move-file.js

@@ -1,10 +1,11 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
+import { cp, mkdir, rename, rm, stat } from 'node:fs/promises';
+import { basename, dirname, join, resolve, sep } from 'node:path';
+import { withAbort } from '../lib/abort.js';
 import { ErrorCode, formatUnknownErrorMessage, isNodeError, McpError, } from '../lib/errors.js';
-import { withAbort } from '../lib/fs-helpers.js';
+import { Logger } from '../lib/logger.js';
 import { assertAllowedFileAccess, validateExistingPath, validatePathForWrite, } from '../lib/paths.js';
 import { MoveFileInputSchema, MoveFileOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildStructuredError, buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 export const MOVE_FILE_TOOL = {
     name: 'mv',
@@ -13,121 +14,124 @@ export const MOVE_FILE_TOOL = {
     inputSchema: MoveFileInputSchema,
     outputSchema: MoveFileOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
-    nuances: ['Cross-device moves fall back to copy+delete.'],
     gotchas: [
         'On POSIX, an existing destination is silently overwritten; on Windows, rename fails with EEXIST if destination exists.',
     ],
     taskSupport: 'forbidden',
 };
-async function handleMoveFile(args, signal) {
-    const sources = args.sources ?? (args.source ? [args.source] : []);
-    if (sources.length === 0) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'No sources provided.');
+function toMoveFailure(source, error, defaultCode = ErrorCode.UNKNOWN) {
+    return {
+        source,
+        error: buildStructuredError(error, defaultCode, source),
+    };
+}
+async function handleMoveError(error, src, validSource, targetPath, movedSources, failed, signal) {
+    if (isNodeError(error) && error.code === 'EXDEV') {
+        try {
+            await withAbort(cp(validSource, targetPath, { recursive: true }), signal);
+        }
+        catch (copyError) {
+            failed.push(toMoveFailure(src, copyError));
+            return;
+        }
+        try {
+            await withAbort(rm(validSource, { recursive: true, force: true }), signal);
+            movedSources.push(validSource);
+        }
+        catch (deleteError) {
+            try {
+                await rm(targetPath, { recursive: true, force: true });
+            }
+            catch {
+                failed.push(toMoveFailure(src, new McpError(ErrorCode.UNKNOWN, `Cross-device move partial: data at both source and destination. ${formatUnknownErrorMessage(deleteError)}`, src)));
+                return;
+            }
+            failed.push(toMoveFailure(src, new McpError(ErrorCode.UNKNOWN, `Cross-device move failed: source not removed. ${formatUnknownErrorMessage(deleteError)}`, src)));
+        }
+    }
+    else {
+        failed.push(toMoveFailure(src, error));
+    }
+}
+async function processSingleMove(src, destIsDirectory, validDest, movedSources, failed, signal) {
+    let validSource;
+    try {
+        validSource = await validateExistingPath(src, signal);
+        assertAllowedFileAccess(src, validSource);
+    }
+    catch (error) {
+        failed.push(toMoveFailure(src, error, ErrorCode.ACCESS_DENIED));
+        return;
+    }
+    const targetPath = destIsDirectory
+        ? join(validDest, basename(validSource))
+        : validDest;
+    if (resolve(validSource) === resolve(targetPath)) {
+        return;
+    }
+    if (resolve(targetPath).startsWith(resolve(validSource) + sep)) {
+        failed.push(toMoveFailure(src, new McpError(ErrorCode.INVALID_INPUT, 'Cannot move a directory into its own subdirectory', src), ErrorCode.INVALID_INPUT));
+        return;
     }
-    const validDest = await validatePathForWrite(args.destination, signal);
-    // Check if destination exists and is a directory
-    let destIsDirectory = false;
     try {
-        const stats = await fs.stat(validDest);
-        destIsDirectory = stats.isDirectory();
+        await withAbort(rename(validSource, targetPath), signal);
+        movedSources.push(validSource);
+    }
+    catch (error) {
+        await handleMoveError(error, src, validSource, targetPath, movedSources, failed, signal);
+    }
+}
+async function getDestinationStatus(validDest) {
+    try {
+        const stats = await stat(validDest);
+        return stats.isDirectory();
     }
     catch (error) {
         if (isNodeError(error) && error.code !== 'ENOENT') {
             throw error;
         }
     }
+    return false;
+}
+function formatMoveMessage(moved, failed, destination) {
+    const movedItemStr = `item${moved === 1 ? '' : 's'}`;
+    const failedItemStr = `item${failed === 1 ? '' : 's'}`;
+    if (failed > 0) {
+        return `Moved ${moved} ${movedItemStr}; failed to move ${failed} ${failedItemStr}`;
+    }
+    return `Successfully moved ${moved} ${movedItemStr} to ${destination}`;
+}
+async function handleMoveFile(args, signal) {
+    const sources = args.sources ?? (args.source ? [args.source] : []);
+    if (sources.length === 0) {
+        throw new McpError(ErrorCode.INVALID_INPUT, 'No sources provided.');
+    }
+    const validDest = await validatePathForWrite(args.destination, signal);
+    const destIsDirectory = await getDestinationStatus(validDest);
     if (sources.length > 1 && !destIsDirectory) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Destination must be an existing directory when moving multiple files.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Destination must be an existing directory for multiple sources.');
     }
-    // Ensure destination parent directory exists if it's not an existing directory
     if (!destIsDirectory) {
-        await withAbort(fs.mkdir(path.dirname(validDest), { recursive: true }), signal);
+        await withAbort(mkdir(dirname(validDest), { recursive: true }), signal);
     }
     const movedSources = [];
     const failed = [];
     for (const src of sources) {
-        let validSource;
-        try {
-            validSource = await validateExistingPath(src, signal);
-            assertAllowedFileAccess(src, validSource);
-        }
-        catch (error) {
-            failed.push({
-                source: src,
-                error: formatUnknownErrorMessage(error),
-            });
-            continue;
-        }
-        const targetPath = destIsDirectory
-            ? path.join(validDest, path.basename(validSource))
-            : validDest;
-        // Prevent moving a file onto itself
-        if (path.resolve(validSource) === path.resolve(targetPath)) {
-            continue;
-        }
-        // Prevent moving a directory into its own subdirectory
-        // Fixes "Missing validation for moving directory into its own subdirectory" finding
-        if (path.resolve(targetPath).startsWith(path.resolve(validSource) + path.sep)) {
-            failed.push({
-                source: src,
-                error: `Cannot move directory '${src}' into its own subdirectory '${targetPath}'`,
-            });
-            continue;
-        }
-        try {
-            await withAbort(fs.rename(validSource, targetPath), signal);
-            movedSources.push(validSource);
-        }
-        catch (error) {
-            if (isNodeError(error) && error.code === 'EXDEV') {
-                // Cross-device link, fallback to copy + delete
-                try {
-                    await withAbort(fs.cp(validSource, targetPath, { recursive: true }), signal);
-                }
-                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 {
-                failed.push({
-                    source: src,
-                    error: formatUnknownErrorMessage(error),
-                });
-            }
+        await processSingleMove(src, destIsDirectory, validDest, movedSources, failed, signal);
+    }
+    const message = formatMoveMessage(movedSources.length, failed.length, args.destination);
+    const movedSource = sources.length === 1 ? movedSources[0] : undefined;
+    const failedSuffix = failed.length > 0 ? ` (${failed.length} failed)` : '';
+    Logger.info(`mv: ${movedSources.length} item(s) → ${args.destination}${failedSuffix}`);
+    if (movedSources.length === 0 && failed.length > 0) {
+        const firstFailure = failed[0];
+        if (firstFailure) {
+            throw new McpError(firstFailure.error.code, message, firstFailure.error.path);
         }
     }
-    const message = failed.length > 0
-        ? `Moved ${movedSources.length} item${movedSources.length === 1 ? '' : 's'}; failed to move ${failed.length} item${failed.length === 1 ? '' : 's'}`
-        : `Successfully moved ${movedSources.length} item${movedSources.length === 1 ? '' : 's'} to ${args.destination}`;
     return buildToolResponse(message, {
         ok: failed.length === 0,
+        ...(movedSource ? { source: movedSource } : {}),
         sources: movedSources,
         destination: validDest,
         ...(failed.length > 0 ? { failed } : {}),
@@ -137,25 +141,26 @@ export function registerMoveFileTool(server, options = {}) {
     const handler = (args, extra) => executeToolWithDiagnostics({
         toolName: 'mv',
         extra,
+        outputSchema: MoveFileOutputSchema,
         timedSignal: {},
         context: { path: args.source ?? args.sources?.[0] },
         run: (signal) => handleMoveFile(args, signal),
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.source ?? args.sources?.[0]),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.source ?? args.sources?.[0]),
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
-            const dest = path.basename(args.destination);
+            const dest = basename(args.destination);
             if (args.source && !args.sources?.length) {
-                return `🛠 mv: ${path.basename(args.source)} → ${dest}`;
+                return `🛠 mv: ${basename(args.source)} → ${dest}`;
             }
             const count = (args.source ? 1 : 0) + (args.sources?.length ?? 0);
             return `🛠 mv: ${count} items → ${dest}`;
         },
         completionMessage: (args, result) => {
-            const dest = path.basename(args.destination);
+            const dest = basename(args.destination);
             if (args.source && !args.sources?.length) {
-                const src = path.basename(args.source);
+                const src = basename(args.source);
                 if (result.isError)
                     return `🛠 mv: ${src} → ${dest} • failed`;
                 return `🛠 mv: ${src} → ${dest}`;

package/dist/tools/read-multiple.js

@@ -1,9 +1,9 @@
-import * as path from 'node:path';
+import { basename } from 'node:path';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { readMultipleFiles } from '../lib/file-operations/metadata.js';
 import { ReadMultipleFilesInputSchema, ReadMultipleFilesOutputSchema, } from '../schemas.js';
-import { buildBatchCompletionSuffix, buildBatchPathContext, buildResourceLink, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildBatchCompletionSuffix, buildBatchPathContext, buildResourceLink, buildStructuredError, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const READ_MANY_TOOL_NAME = 'read_many';
 const READ_MANY_TOOL_LABEL = '🕮 read_many';
@@ -17,13 +17,9 @@ export const READ_MANY_TOOL = {
     outputSchema: ReadMultipleFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
     taskSupport: 'optional',
-    nuances: ['Total read budget is capped by `MAX_READ_MANY_TOTAL_SIZE`.'],
-    gotchas: [
-        'Per-file `truncationReason` can be `head`, `tail`, `range`, or `externalized`.',
-    ],
 };
 function buildReadManyResourceName(filePath) {
-    return `read:${path.basename(filePath)}`;
+    return `read:${basename(filePath)}`;
 }
 function toStructuredReadManyResult(result) {
     const structuredResult = {
@@ -72,8 +68,12 @@ function resolveReadManyTruncationReason(result) {
 }
 function maybeExternalizeReadManyResult(result, resourceStore) {
     const truncationReason = resolveReadManyTruncationReason(result);
+    const { error, ...rest } = result;
     const baseResult = {
-        ...result,
+        ...rest,
+        ...(error
+            ? { error: buildStructuredError(error, ErrorCode.UNKNOWN, result.path) }
+            : {}),
         ...(truncationReason ? { truncationReason } : {}),
     };
     if (!result.content) {
@@ -89,12 +89,13 @@ function maybeExternalizeReadManyResult(result, resourceStore) {
         truncated: true,
         resourceUri: externalized.entry.uri,
         truncationReason: 'externalized',
+        expiresAt: externalized.entry.expiresAt,
     };
 }
 function buildReadManyTextSection(result) {
     const header = `=== ${result.path} ===`;
     if (result.error) {
-        return `${header}\nError: ${result.error}`;
+        return `${header}\nError [${result.error.code}]: ${result.error.message}`;
     }
     return `${header}\n${result.content ?? ''}`;
 }
@@ -128,6 +129,9 @@ function buildReadManyResponsePayload(results, resourceStore) {
                 uri: mappedResult.resourceUri,
                 name: buildReadManyResourceName(mappedResult.path),
                 description: FULL_FILE_CONTENTS_DESCRIPTION,
+                ...(mappedResult.expiresAt
+                    ? { expiresAt: mappedResult.expiresAt }
+                    : {}),
             }));
         }
         if (mappedResult.error === undefined)
@@ -162,6 +166,7 @@ export function registerReadMultipleFilesTool(server, options = {}) {
         return executeToolWithDiagnostics({
             toolName: READ_MANY_TOOL_NAME,
             extra,
+            outputSchema: ReadMultipleFilesOutputSchema,
             timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
             context: { path: primaryPath },
             run: async (signal) => {
@@ -186,7 +191,7 @@ export function registerReadMultipleFilesTool(server, options = {}) {
                     throw error;
                 }
             },
-            onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FILE, primaryPath),
+            onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_FILE, primaryPath),
         });
     };
     const wrappedHandler = wrapToolHandler(handler, {

package/dist/tools/read.js

@@ -1,5 +1,5 @@
-import * as path from 'node:path';
 import { createHash } from 'node:crypto';
+import { basename } from 'node:path';
 import { DEFAULT_SEARCH_TIMEOUT_MS, MAX_TEXT_FILE_SIZE, } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { readFile } from '../lib/fs-helpers.js';
@@ -24,7 +24,7 @@ const READ_TOOL_NAME = 'read';
 const READ_TOOL_LABEL = '🕮 read';
 const FULL_FILE_CONTENTS_DESCRIPTION = 'Full file contents';
 function buildReadResourceName(filePath) {
-    return `read:${path.basename(filePath)}`;
+    return `read:${basename(filePath)}`;
 }
 function buildReadOptions(args, signal) {
     const options = {
@@ -99,7 +99,7 @@ function maybeBuildExternalizedReadResponse(filePath, content, structured, resou
     ]);
 }
 function buildReadProgressMessage(args) {
-    const name = path.basename(args.path);
+    const name = basename(args.path);
     if (args.startLine !== undefined) {
         const end = args.endLine ?? '…';
         return `${READ_TOOL_LABEL}: ${name} [lines ${args.startLine}–${end}]`;
@@ -111,12 +111,10 @@ function buildReadProgressMessage(args) {
     return `${READ_TOOL_LABEL}: ${name}`;
 }
 function buildReadCompletionMessage(args, result) {
-    const name = path.basename(args.path);
+    const name = basename(args.path);
     if (result.isError)
         return `${READ_TOOL_LABEL}: ${name} • failed`;
     const structured = result.structuredContent;
-    if (!structured.ok)
-        return `${READ_TOOL_LABEL}: ${name} • failed`;
     const lines = structured.linesRead ?? structured.totalLines;
     if (structured.startLine !== undefined) {
         const end = structured.linesRead
@@ -158,10 +156,11 @@ export function registerReadFileTool(server, options = {}) {
     const handler = (args, extra) => executeToolWithDiagnostics({
         toolName: READ_TOOL_NAME,
         extra,
+        outputSchema: ReadFileOutputSchema,
         timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
         context: { path: args.path },
         run: (signal) => handleReadFile(args, signal, options.resourceStore),
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FILE, args.path),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_FILE, args.path),
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,