@j0hanz/filesystem-mcp 1.11.1 → 1.13.0

package/dist/server/bootstrap.js

@@ -5,7 +5,7 @@ import { InMemoryTaskMessageQueue, InMemoryTaskStore, } from '@modelcontextproto
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { isInitializeRequest, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { isInitializeRequest, LATEST_PROTOCOL_VERSION, SetLevelRequestSchema, SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
 import { DEFAULT_LOG_LEVEL, parseEnvInt } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { withAllowedDirectoriesState } from '../lib/paths.js';
@@ -243,7 +243,7 @@ async function readRequestBody(req) {
         req.on('error', reject);
     });
 }
-async function createHttpSession(options, sessions) {
+async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
     const mcpServer = await createServer(options);
     const rootsManager = getRootsManager(mcpServer);
     rootsManager.registerHandlers(mcpServer);
@@ -255,6 +255,7 @@ async function createHttpSession(options, sessions) {
                 server: mcpServer,
                 rootsManager,
                 transport,
+                negotiatedProtocolVersion,
             });
             rootsManager.logMissingDirectoriesIfNeeded(mcpServer);
         },
@@ -270,7 +271,12 @@ async function createHttpSession(options, sessions) {
         });
     };
     await mcpServer.connect(transport);
-    return { server: mcpServer, rootsManager, transport };
+    return {
+        server: mcpServer,
+        rootsManager,
+        transport,
+        negotiatedProtocolVersion,
+    };
 }
 function sendJsonRpcError(res, status, code, message) {
     res.writeHead(status, { 'Content-Type': 'application/json' });
@@ -299,6 +305,29 @@ function getSessionId(req) {
         ? rawSessionId
         : undefined;
 }
+function getProtocolVersionHeader(req) {
+    const rawProtocolVersion = req.headers['mcp-protocol-version'];
+    return typeof rawProtocolVersion === 'string'
+        ? rawProtocolVersion
+        : undefined;
+}
+function resolveNegotiatedProtocolVersion(requestedVersion) {
+    return SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion)
+        ? requestedVersion
+        : LATEST_PROTOCOL_VERSION;
+}
+function ensureSessionProtocolVersion(req, res, session) {
+    const protocolVersion = getProtocolVersionHeader(req);
+    if (!protocolVersion) {
+        sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: Missing MCP-Protocol-Version header');
+        return false;
+    }
+    if (protocolVersion !== session.negotiatedProtocolVersion) {
+        sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, `Bad Request: MCP-Protocol-Version must match negotiated version ${session.negotiatedProtocolVersion}`);
+        return false;
+    }
+    return true;
+}
 function isAuthorizedBearer(apiKey, authHeader) {
     const bearerPrefix = 'Bearer ';
     if (typeof authHeader !== 'string' || !authHeader.startsWith(bearerPrefix)) {
@@ -385,6 +414,10 @@ export async function startHttpServer(port, options) {
                         discardRequestBody(req);
                         return;
                     }
+                    if (!ensureSessionProtocolVersion(req, res, session)) {
+                        discardRequestBody(req);
+                        return;
+                    }
                     const body = await readRequestBody(req);
                     await handleSessionTransportRequest(session, req, res, body);
                     return;
@@ -396,7 +429,7 @@ export async function startHttpServer(port, options) {
                         sendJsonRpcError(res, 503, JSON_RPC_SERVER_ERROR, 'Too many sessions');
                         return;
                     }
-                    const session = await createHttpSession(options, sessions);
+                    const session = await createHttpSession(options, sessions, resolveNegotiatedProtocolVersion(body.params.protocolVersion));
                     await handleSessionTransportRequest(session, req, res, body);
                     return;
                 }
@@ -411,6 +444,8 @@ export async function startHttpServer(port, options) {
                 const session = getSessionOrRespondNotFound(sessions, sessionId, res);
                 if (!session)
                     return;
+                if (!ensureSessionProtocolVersion(req, res, session))
+                    return;
                 await handleSessionTransportRequest(session, req, res);
             }
             else {

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

@@ -3,7 +3,7 @@ import { type AllowedDirectoriesState } from '../lib/paths.js';
 import { type LoggingState } from './bootstrap.js';
 import type { ServerOptions } from './bootstrap.js';
 export declare class RootsManager {
-    private rootsUpdateTimeout;
+    private _debouncedUpdate;
     private rootDirectories;
     private allowedDirectoriesState;
     private clientInitialized;

package/dist/server/roots-manager.js

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
 import { getValidRootDirectories, isPathWithinDirectories, normalizePath, resolveAllowedDirectoriesState, setAllowedDirectoriesStateResolved, } from '../lib/paths.js';
-import { isRecord } from '../lib/utils.js';
+import { debounce, isRecord } from '../lib/utils.js';
 import { logToMcp } from './bootstrap.js';
 const ROOTS_TIMEOUT_MS = 5000;
 const ROOTS_DEBOUNCE_MS = 100;
@@ -81,7 +81,7 @@ async function filterRootsWithinBaseline(roots, baseline, signal) {
     });
 }
 export class RootsManager {
-    rootsUpdateTimeout;
+    _debouncedUpdate;
     rootDirectories = [];
     allowedDirectoriesState = {
         primary: [],
@@ -102,9 +102,9 @@ export class RootsManager {
         return this.clientInitialized;
     }
     destroy() {
-        if (this.rootsUpdateTimeout) {
-            clearTimeout(this.rootsUpdateTimeout);
-            this.rootsUpdateTimeout = undefined;
+        if (this._debouncedUpdate) {
+            this._debouncedUpdate.cancel();
+            this._debouncedUpdate = undefined;
         }
     }
     getAllowedDirectoriesState() {
@@ -149,15 +149,10 @@ export class RootsManager {
         }
     }
     scheduleRootsUpdate(server) {
-        if (this.rootsUpdateTimeout) {
-            this.rootsUpdateTimeout.refresh();
-            return;
-        }
-        this.rootsUpdateTimeout = setTimeout(() => {
-            this.rootsUpdateTimeout = undefined;
-            void this.updateRootsFromClient(server);
+        this._debouncedUpdate ??= debounce((s) => {
+            void this.updateRootsFromClient(s);
         }, ROOTS_DEBOUNCE_MS);
-        this.rootsUpdateTimeout.unref();
+        this._debouncedUpdate(server);
     }
     logMissingDirectories(server) {
         if (this.options.allowCwd) {

package/dist/tools/apply-patch.js

@@ -1,9 +1,9 @@
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { readFile, stat } from 'node:fs/promises';
 import { applyPatch, parsePatch } from 'diff';
-import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
+import { MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
-import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
+import { atomicWriteFile, processInParallel, withAbort, } from '../lib/fs-helpers.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
@@ -29,15 +29,6 @@ function assertPatchTargetSizeWithinLimit(filePath, size, maxFileSize) {
         return;
     throw new McpError(ErrorCode.E_TOO_LARGE, `File too large for patch: ${filePath} (${size} bytes > ${maxFileSize} bytes).`, filePath, { size, maxFileSize });
 }
-function assertPatchHasHunks(patch) {
-    if (!patch.trim()) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch content is empty.');
-    }
-    const hasHunk = /@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/u.test(patch);
-    if (!hasHunk) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch must include unified hunk headers (e.g., @@ -1,2 +1,2 @@).');
-    }
-}
 function countStructuredPatchStats(diff) {
     let linesAdded = 0;
     let linesRemoved = 0;
@@ -63,12 +54,12 @@ function extractPatchTargetPath(diff) {
         return stripGitPrefix(diff.oldFileName);
     return undefined;
 }
-async function applyPatchToFile(filePath, diff, options, signal) {
+async function applyDiff(filePath, diff, options, signal) {
     const validPath = await validateExistingPath(filePath, signal);
     assertAllowedFileAccess(filePath, validPath);
-    const stats = await withAbort(fs.stat(validPath), signal);
+    const stats = await withAbort(stat(validPath), signal);
     assertPatchTargetSizeWithinLimit(validPath, stats.size, MAX_TEXT_FILE_SIZE);
-    const content = await fs.readFile(validPath, { encoding: 'utf-8', signal });
+    const content = await readFile(validPath, { encoding: 'utf-8', signal });
     const patched = applyPatch(content, diff, {
         fuzzFactor: options.fuzzFactor,
         autoConvertLineEndings: options.autoConvertLineEndings,
@@ -89,32 +80,33 @@ async function applyPatchToFile(filePath, diff, options, signal) {
     }
     return { path: validPath, applied: true, ...patchStats };
 }
-async function handleMultiFilePatch(basePath, parsed, options, signal) {
+async function processMultiFilePatch(basePath, parsed, options, signal) {
     const validBase = await validateExistingPath(basePath, signal);
-    const results = [];
-    for (const diff of parsed) {
+    const promises = parsed.map((diff) => {
         const fileName = extractPatchTargetPath(diff);
         if (!fileName) {
-            results.push({
+            return () => Promise.resolve({
                 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),
-            });
-        }
-    }
+        return async () => {
+            try {
+                const result = await applyDiff(filePath, diff, options, signal);
+                return { ...result, path: fileName };
+            }
+            catch (error) {
+                return {
+                    path: fileName,
+                    applied: false,
+                    error: formatUnknownErrorMessage(error),
+                };
+            }
+        };
+    });
+    const { results } = await processInParallel(promises, (task) => task(), PARALLEL_CONCURRENCY, signal);
     const totals = results.reduce((acc, r) => {
         if (r.applied) {
             acc.applied++;
@@ -137,24 +129,28 @@ async function handleMultiFilePatch(basePath, parsed, options, signal) {
     });
 }
 async function handleApplyPatch(args, signal) {
-    assertPatchHasHunks(args.patch);
+    if (!args.patch.trim()) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch content is empty.');
+    }
     const fuzzFactor = args.fuzzFactor ?? 0;
     const parsed = parsePatch(args.patch);
+    const hasHunks = parsed.some((p) => p.hunks.length > 0);
+    if (!hasHunks) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch must include unified hunk headers (e.g., @@ -1,2 +1,2 @@).');
+    }
     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);
+        return processMultiFilePatch(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);
+    const result = await applyDiff(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.'
@@ -196,7 +192,7 @@ export function registerApplyPatchTool(server, options = {}) {
                 return `🛠 patch: ${name} • failed`;
             const added = sc.linesAdded ?? 0;
             const removed = sc.linesRemoved ?? 0;
-            const dry = args.dryRun ? 'dry run — ' : '';
+            const dry = args.dryRun ? 'dry run ' : '';
             if (added > 0 || removed > 0)
                 return `🛠 patch: ${name} • ${dry} +${added} -${removed}`;
             return `🛠 patch: ${name} • ${dry}no changes`;

package/dist/tools/calculate-hash.js

@@ -2,6 +2,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { createHash } from 'node:crypto';
 import { createReadStream } from 'node:fs';
+import { pipeline } from 'node:stream/promises';
 import { PARALLEL_CONCURRENCY } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations/core.js';
@@ -26,15 +27,9 @@ export const CALCULATE_HASH_TOOL = {
     taskSupport: 'optional',
 };
 async function hashFile(filePath, encoding, signal) {
-    assertNotAborted(signal);
-    const hashOp = createHash('sha256');
-    const stream = createReadStream(filePath, { signal });
-    for await (const chunk of stream) {
-        hashOp.update(chunk);
-        assertNotAborted(signal);
-    }
-    assertNotAborted(signal);
-    return encoding === undefined ? hashOp.digest() : hashOp.digest(encoding);
+    const hasher = createHash('sha256');
+    await pipeline(createReadStream(filePath, { signal, highWaterMark: 64 * 1024 }), hasher, { signal });
+    return encoding ? hasher.digest(encoding) : hasher.digest();
 }
 function toStableRelativePath(root, entryPath) {
     const relativePath = path.relative(root, entryPath);
@@ -84,25 +79,27 @@ async function hashDirectory(dirPath, options = {}) {
         });
     }
     assertNotAborted(signal);
-    // Phase 2: hash files concurrently with bounded pool.
     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);
-        const batchResults = await Promise.all(batch.map(async ({ filePath, relativePath }) => {
-            const fileHash = await hashFile(filePath, undefined, signal);
-            return { path: relativePath, hash: fileHash };
-        }));
-        entries.push(...batchResults);
-        filesHashed += batchResults.length;
-        reportPeriodicProgress(onProgress, filesHashed, {
-            throttleModulo: 25,
-            total: totalFiles,
-        });
-    }
+    const taskQueue = filteredPaths;
+    const worker = async () => {
+        while (taskQueue.length > 0) {
+            const task = taskQueue.pop();
+            if (!task)
+                break;
+            assertNotAborted(signal);
+            const fileHash = await hashFile(task.filePath, undefined, signal);
+            entries.push({ path: task.relativePath, hash: fileHash });
+            filesHashed++;
+            reportPeriodicProgress(onProgress, filesHashed, {
+                throttleModulo: 25,
+                total: totalFiles,
+            });
+        }
+    };
+    await Promise.all(Array.from({ length: concurrency }, () => worker()));
     reportPeriodicProgress(onProgress, filesHashed, {
         throttleModulo: 25,
         total: totalFiles,

package/dist/tools/diff-files.js

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { createTwoFilesPatch } from 'diff';
+import { formatPatch, structuredPatch } from 'diff';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
@@ -20,19 +20,18 @@ export const DIFF_FILES_TOOL = {
     gotchas: ['`isIdentical=true` means no hunks (`@@`) and empty diff.'],
     taskSupport: 'forbidden',
 };
-function computeDiffStats(patch) {
+function computeDiffStats(hunks) {
     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++;
+    for (const hunk of hunks) {
+        for (const line of hunk.lines) {
+            if (line.startsWith('+') && !line.startsWith('+++'))
+                linesAdded++;
+            else if (line.startsWith('-') && !line.startsWith('---'))
+                linesRemoved++;
+        }
     }
-    return { linesAdded, linesRemoved, hunksCount };
+    return { linesAdded, linesRemoved, hunksCount: hunks.length };
 }
 function assertDiffFileSizeWithinLimit(filePath, size, maxFileSize) {
     if (size <= maxFileSize)
@@ -55,14 +54,23 @@ async function handleDiffFiles(args, signal, resourceStore) {
         fs.readFile(originalPath, { encoding: 'utf-8', signal }),
         fs.readFile(modifiedPath, { encoding: 'utf-8', signal }),
     ]);
-    const patch = createTwoFilesPatch(path.basename(originalPath), path.basename(modifiedPath), originalContent, modifiedContent, undefined, undefined, {
-        ...(args.context !== undefined ? { context: args.context } : {}),
-        ignoreWhitespace: args.ignoreWhitespace,
-        stripTrailingCr: args.stripTrailingCr,
+    const patchObj = await new Promise((resolve) => {
+        structuredPatch(path.basename(originalPath), path.basename(modifiedPath), originalContent, modifiedContent, undefined, undefined, {
+            ...(args.context !== undefined ? { context: args.context } : {}),
+            ignoreWhitespace: args.ignoreWhitespace,
+            stripTrailingCr: args.stripTrailingCr,
+            timeout: 10000,
+            callback: (res) => {
+                resolve(res);
+            },
+        });
     });
-    const isIdentical = !patch.includes('@@');
-    const diffText = isIdentical ? '' : patch;
-    const stats = isIdentical ? undefined : computeDiffStats(patch);
+    if (!patchObj) {
+        throw new McpError(ErrorCode.E_TIMEOUT, `Diff computation timed out or failed due to complexity.`, originalPath);
+    }
+    const isIdentical = patchObj.hunks.length === 0;
+    const diffText = isIdentical ? '' : formatPatch(patchObj);
+    const stats = isIdentical ? undefined : computeDiffStats(patchObj.hunks);
     const externalized = maybeExternalizeTextContent(resourceStore, diffText, {
         name: 'diff:patch',
         mimeType: 'text/x-diff',

package/dist/tools/edit-file.d.ts

@@ -3,5 +3,8 @@ import type { z } from 'zod';
 import { EditFileInputSchema, EditFileOutputSchema } from '../schemas.js';
 import { type ToolContract, type ToolRegistrationOptions, type ToolResponse } from './shared.js';
 export declare const EDIT_FILE_TOOL: ToolContract;
-export declare function handleEditFile(args: z.infer<typeof EditFileInputSchema>, signal?: AbortSignal): Promise<ToolResponse<z.infer<typeof EditFileOutputSchema>>>;
+type EditInput = z.infer<typeof EditFileInputSchema>;
+type EditOutput = z.infer<typeof EditFileOutputSchema>;
+export declare function handleEditFile(args: EditInput, signal?: AbortSignal): Promise<ToolResponse<EditOutput>>;
 export declare function registerEditFileTool(server: McpServer, options?: ToolRegistrationOptions): void;
+export {};