@j0hanz/filesystem-mcp 1.17.0 → 1.17.1

package/dist/completions.js

@@ -1,5 +1,6 @@
-import { readdir, stat } from 'node:fs/promises';
+import { readdir, realpath, stat } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, parse, resolve, sep, } from 'node:path';
+import { z } from 'zod';
 import { getAllowedDirectories, isPathWithinDirectories, normalizePath, toPosixPath, } from './lib/paths.js';
 import { isRecord } from './lib/utils.js';
 import { getSortedToolContracts } from './resources/tool-info.js';
@@ -46,9 +47,63 @@ const PATH_ARGUMENTS = new Set([
 const DESTINATION_CONTEXT_KEYS = ['source', 'path', 'cwd', 'root'];
 const PRIMARY_PATH_CONTEXT_KEYS = ['path', 'cwd', 'root'];
 const DEFAULT_CONTEXT_KEYS = ['path', 'source', 'cwd', 'root'];
-const ENUM_ARGUMENT_VALUES = new Map([
-    ['sortby', ['modified', 'name', 'path', 'size', 'type']],
-]);
+function extractEnumValuesFromSchema(argumentName, schema) {
+    const properties = getInputSchemaProperties(schema);
+    if (!properties || typeof properties !== 'object')
+        return undefined;
+    for (const [key, value] of Object.entries(properties)) {
+        if (key.toLowerCase() !== argumentName)
+            continue;
+        if (value === null || typeof value !== 'object' || !('enum' in value)) {
+            return undefined;
+        }
+        const enumValues = value.enum;
+        if (!Array.isArray(enumValues))
+            return undefined;
+        const stringValues = enumValues.filter((entry) => typeof entry === 'string');
+        return stringValues.length > 0 ? stringValues : undefined;
+    }
+    return undefined;
+}
+function getInputSchemaProperties(schema) {
+    const { properties } = z.toJSONSchema(schema, { io: 'input' });
+    if (!properties || typeof properties !== 'object')
+        return undefined;
+    return properties;
+}
+function intersectEnumValueSets(valueSets) {
+    const [firstSet, ...restSets] = valueSets;
+    if (!firstSet)
+        return [];
+    return firstSet.filter((value) => restSets.every((candidateSet) => candidateSet.includes(value)));
+}
+function buildEnumArgumentValues() {
+    const valuesByArgument = new Map();
+    for (const contract of getSortedToolContracts()) {
+        const properties = getInputSchemaProperties(contract.inputSchema);
+        if (!properties || typeof properties !== 'object')
+            continue;
+        for (const key of Object.keys(properties)) {
+            const normalizedKey = key.toLowerCase();
+            const values = extractEnumValuesFromSchema(normalizedKey, contract.inputSchema);
+            if (!values)
+                continue;
+            const existing = valuesByArgument.get(normalizedKey) ?? [];
+            existing.push(values);
+            valuesByArgument.set(normalizedKey, existing);
+        }
+    }
+    const result = new Map();
+    for (const [argumentName, valueSets] of valuesByArgument) {
+        const values = valueSets.length === 1
+            ? (valueSets[0] ?? [])
+            : intersectEnumValueSets(valueSets);
+        if (values.length > 0) {
+            result.set(argumentName, values);
+        }
+    }
+    return result;
+}
 function isPathLikeArgumentName(argName) {
     return (PATH_ARGUMENTS.has(argName) ||
         argName.endsWith('paths') ||
@@ -58,8 +113,8 @@ function isPathLikeArgumentName(argName) {
         argName.endsWith('dirs') ||
         argName.endsWith('dir'));
 }
-function getEnumCompletions(argName, currentValue) {
-    const values = ENUM_ARGUMENT_VALUES.get(argName);
+function getEnumCompletions(argName, currentValue, enumArgumentValues) {
+    const values = enumArgumentValues.get(argName);
     if (!values)
         return undefined;
     const prefix = currentValue.toLowerCase();
@@ -267,18 +322,29 @@ function resolveContextCandidatePath(candidate, allowed) {
     return resolveNamedRootPath(candidate, allowed);
 }
 async function toAllowedContextDirectory(resolved, allowed) {
-    if (!isPathWithinDirectories(resolved, allowed))
-        return undefined;
+    const parent = dirname(resolved);
+    if (await isAllowedCompletionDirectory(resolved, allowed)) {
+        return resolved;
+    }
+    return (await isAllowedCompletionDirectory(parent, allowed))
+        ? parent
+        : undefined;
+}
+async function isAllowedCompletionDirectory(path, allowed) {
+    if (!isPathWithinDirectories(path, allowed))
+        return false;
     try {
-        const stats = await stat(resolved);
-        if (stats.isDirectory())
-            return resolved;
+        const [stats, resolvedRealPath] = await Promise.all([
+            stat(path),
+            realpath(path),
+        ]);
+        if (!stats.isDirectory())
+            return false;
+        return isPathWithinDirectories(normalizePath(resolvedRealPath), allowed);
     }
     catch {
-        // Fall back to parent path best-effort resolution.
+        return false;
     }
-    const parent = dirname(resolved);
-    return isPathWithinDirectories(parent, allowed) ? parent : undefined;
 }
 async function resolveContextBaseDirectory(argumentName, contextArguments, allowed) {
     if (!hasContextArguments(contextArguments)) {
@@ -371,7 +437,7 @@ function getSearchContext(currentValue, allowed, contextBase) {
 }
 async function findMatchesInDirectory(searchDir, prefix, allowed) {
     const matches = [];
-    if (!isPathWithinDirectories(searchDir, allowed)) {
+    if (!(await isAllowedCompletionDirectory(searchDir, allowed))) {
         return matches;
     }
     try {
@@ -460,6 +526,7 @@ function handleTopicAndToolCompletions(ref, argName, argumentValue, topicValues,
 export function registerCompletions(server, instructions = '') {
     const topicValues = extractTopicCompletions(instructions);
     const toolNameValues = extractToolNameCompletions();
+    const enumArgumentValues = buildEnumArgumentValues();
     server.server.setRequestHandler('completion/complete', async (request) => {
         const { params } = request;
         const { argument, ref } = params;
@@ -467,7 +534,7 @@ export function registerCompletions(server, instructions = '') {
         const predef = handleTopicAndToolCompletions(ref, argName, argument.value, topicValues, toolNameValues);
         if (predef)
             return predef;
-        const enumResult = getEnumCompletions(argName, argument.value);
+        const enumResult = getEnumCompletions(argName, argument.value, enumArgumentValues);
         if (enumResult) {
             return buildCompletionResponse(enumResult);
         }

package/dist/lib/constants.d.ts

@@ -5,7 +5,7 @@ export declare const DEFAULT_TASK_TTL_MS: number;
 export declare const MAX_TASK_TTL_MS: number;
 export declare const MAX_CONCURRENT_TASKS: number;
 export declare const TASK_CANCEL_POLL_MS = 2000;
-export declare const INIT_HANDSHAKE_TIMEOUT_MS: number;
+export declare function getInitHandshakeTimeoutMs(): number;
 export declare const INIT_TIMEOUT_CLOSE: boolean;
 export declare const TASK_POLL_INTERVAL_MS = 100;
 export declare const PARALLEL_CONCURRENCY: number;

package/dist/lib/constants.js

@@ -76,7 +76,9 @@ export const DEFAULT_TASK_TTL_MS = 5 * 60 * 1000;
 export const MAX_TASK_TTL_MS = parseEnvInt('FILESYSTEM_MCP_MAX_TASK_TTL_MS', 60 * 60 * 1000, 1_000, 24 * 60 * 60 * 1000);
 export const MAX_CONCURRENT_TASKS = parseEnvInt('FILESYSTEM_MCP_MAX_CONCURRENT_TASKS', 100, 1, 10_000);
 export const TASK_CANCEL_POLL_MS = 2_000;
-export const INIT_HANDSHAKE_TIMEOUT_MS = parseEnvInt('FS_INIT_HANDSHAKE_TIMEOUT_MS', 30_000, 1_000, 300_000);
+export function getInitHandshakeTimeoutMs() {
+    return parseEnvInt('FS_INIT_HANDSHAKE_TIMEOUT_MS', 30_000, 1_000, 300_000);
+}
 export const INIT_TIMEOUT_CLOSE = parseTrueEnvFlag(process.env['FS_INIT_TIMEOUT_CLOSE']);
 export const TASK_POLL_INTERVAL_MS = 100;
 // Auto-tuned parallelism based on CPU cores (no env override)

package/dist/lib/fs-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { Stats } from 'node:fs';
+import { type Stats } from 'node:fs';
 import { type FileHandle } from 'node:fs/promises';
 import type { FileType } from '../config.js';
 interface ParallelResult<R> {
@@ -12,6 +12,7 @@ export declare function processInParallel<T, R>(items: T[], processor: (item: T)
 export declare function getFileType(stats: Stats): FileType;
 export declare function isHidden(name: string): boolean;
 export declare function isProbablyBinary(filePath: string, existingHandle?: FileHandle, signal?: AbortSignal): Promise<boolean>;
+export declare function calculateFileContentHash(filePath: string, signal?: AbortSignal): Promise<string>;
 type ReadMode = 'head' | 'full' | 'range' | 'tail';
 interface ReadFileOptions {
     encoding?: BufferEncoding;

package/dist/lib/fs-helpers.js

@@ -51,9 +51,11 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { isUtf8 } from 'node:buffer';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { createReadStream } from 'node:fs';
 import { open, rename, stat, unlink, writeFile, } from 'node:fs/promises';
 import { extname } from 'node:path';
+import { pipeline } from 'node:stream/promises';
 import { assertNotAborted, withAbort } from './abort.js';
 import { BINARY_CHECK_BUFFER_SIZE, KNOWN_BINARY_EXTENSIONS, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from './constants.js';
 import { ErrorCode, McpError, normalizeUnknownError } from './errors.js';
@@ -192,6 +194,11 @@ function isBinarySlice(slice) {
         return true;
     return !isUtf8(slice);
 }
+export async function calculateFileContentHash(filePath, signal) {
+    const hasher = createHash('sha256');
+    await pipeline(createReadStream(filePath, { signal, highWaterMark: STREAM_CHUNK_SIZE }), hasher, { signal });
+    return hasher.digest('hex');
+}
 function validateReadOptions(options) {
     const hasHead = options.head !== undefined;
     const hasTail = options.tail !== undefined;
@@ -298,24 +305,6 @@ async function readFileBufferWithLimit(handle, maxSize, requestedPath, signal) {
     }
     return Buffer.concat(chunks, totalSize);
 }
-async function headFile(handle, numLines, encoding = 'utf-8', maxBytesRead, signal) {
-    assertNotAborted(signal);
-    const lines = [];
-    let estimatedBytes = 0;
-    const hasMaxBytes = maxBytesRead !== undefined;
-    const newlineBytes = Buffer.byteLength('\n', encoding);
-    for await (const line of handle.readLines({ encoding, signal })) {
-        lines.push(line);
-        if (lines.length >= numLines)
-            break;
-        if (!hasMaxBytes)
-            continue;
-        estimatedBytes += Buffer.byteLength(line, encoding) + newlineBytes;
-        if (estimatedBytes >= maxBytesRead)
-            break;
-    }
-    return lines.join('\n');
-}
 function countLines(content) {
     if (content.length === 0)
         return 0;
@@ -327,9 +316,37 @@ function countLines(content) {
     return count;
 }
 async function readHeadContent(handle, head, options) {
-    const content = await headFile(handle, head, options.encoding, options.maxSize, options.signal);
-    const linesRead = countLines(content);
-    const hasMoreLines = linesRead >= head;
+    assertNotAborted(options.signal);
+    const lines = [];
+    let estimatedBytes = 0;
+    const newlineBytes = Buffer.byteLength('\n', options.encoding);
+    const iterator = handle
+        .readLines({ encoding: options.encoding, signal: options.signal })[Symbol.asyncIterator]();
+    let hasMoreLines = false;
+    let next = await iterator.next();
+    try {
+        while (!next.done) {
+            const line = next.value;
+            lines.push(line);
+            estimatedBytes +=
+                Buffer.byteLength(line, options.encoding) + newlineBytes;
+            if (estimatedBytes >= options.maxSize) {
+                hasMoreLines = true;
+                break;
+            }
+            if (lines.length === head) {
+                const peek = await iterator.next();
+                hasMoreLines = !peek.done;
+                break;
+            }
+            next = await iterator.next();
+        }
+    }
+    finally {
+        await iterator.return?.();
+    }
+    const content = lines.join('\n');
+    const linesRead = lines.length;
     return {
         content,
         truncated: hasMoreLines,

package/dist/server/bootstrap.js

@@ -4,7 +4,8 @@ import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
 import { channel } from 'node:diagnostics_channel';
 import { readFile } from 'node:fs/promises';
 import { createServer as createHttpServer, } from 'node:http';
-import { DEFAULT_LOG_LEVEL, INIT_HANDSHAKE_TIMEOUT_MS, INIT_TIMEOUT_CLOSE, parseEnvInt, } from '../lib/constants.js';
+import { inspect } from 'node:util';
+import { DEFAULT_LOG_LEVEL, getInitHandshakeTimeoutMs, INIT_TIMEOUT_CLOSE, parseEnvInt, } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { createLoggingState, Logger, logToMcp, SessionContext, } from '../lib/logger.js';
 import { withAllowedDirectoriesState } from '../lib/paths.js';
@@ -44,9 +45,17 @@ const activeServers = new Map();
 // For stdio (single session without a specific ID)
 let stdioServer;
 function stringifyData(data) {
-    if (!data)
+    if (data === undefined)
         return '';
-    return ` ${typeof data === 'string' ? data : JSON.stringify(data)}`;
+    if (typeof data === 'string')
+        return ` ${data}`;
+    if (data === null ||
+        typeof data === 'number' ||
+        typeof data === 'boolean' ||
+        typeof data === 'bigint') {
+        return ` ${String(data)}`;
+    }
+    return ` ${inspect(data, { depth: 4, colors: false, compact: 3 })}`;
 }
 channel('filesystem-mcp:log').subscribe((message) => {
     const event = message;
@@ -533,14 +542,15 @@ export async function startHttpServer(port, options) {
             handleHttpRequestError(error, res);
         }
     }
-    const SWEEP_INTERVAL_MS = INIT_HANDSHAKE_TIMEOUT_MS * 2;
+    const initHandshakeTimeoutMs = getInitHandshakeTimeoutMs();
+    const SWEEP_INTERVAL_MS = initHandshakeTimeoutMs * 2;
     const sweepTimer = setInterval(() => {
         const now = Date.now();
         for (const [sessionId, session] of sessions) {
             if (!session.rootsManager.isInitialized() &&
-                now - session.createdAt > INIT_HANDSHAKE_TIMEOUT_MS) {
+                now - session.createdAt > initHandshakeTimeoutMs) {
                 Logger.warn(`[HTTP] Evicting stale session ${sessionId}: client never sent notifications/initialized`);
-                session.server.close().catch((err) => {
+                session.close().catch((err) => {
                     Logger.error(`[HTTP] Error closing stale session ${sessionId}:`, formatUnknownErrorMessage(err));
                 });
             }

package/dist/server/roots-manager.js

@@ -3,7 +3,7 @@ import { channel } from 'node:diagnostics_channel';
 import { realpath } from 'node:fs/promises';
 import { z } from 'zod';
 import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/abort.js';
-import { INIT_HANDSHAKE_TIMEOUT_MS } from '../lib/constants.js';
+import { getInitHandshakeTimeoutMs } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { Logger, logToMcp } from '../lib/logger.js';
 import { getValidRootDirectories, isPathWithinDirectories, normalizePath, resolveAllowedDirectoriesState, setAllowedDirectoriesStateResolved, } from '../lib/paths.js';
@@ -128,6 +128,7 @@ export class RootsManager {
         }
     }
     registerHandlers(server, onInitTimeout) {
+        const initHandshakeTimeoutMs = getInitHandshakeTimeoutMs();
         server.server.setNotificationHandler('notifications/initialized', async () => {
             if (this.initTimer) {
                 clearTimeout(this.initTimer);
@@ -146,14 +147,14 @@ export class RootsManager {
                 if (LIFECYCLE_CHANNEL.hasSubscribers) {
                     LIFECYCLE_CHANNEL.publish({
                         phase: 'init_timeout',
-                        timeoutMs: INIT_HANDSHAKE_TIMEOUT_MS,
+                        timeoutMs: initHandshakeTimeoutMs,
                     });
                 }
-                logToMcp(server, 'warning', `Client did not send notifications/initialized within ${String(INIT_HANDSHAKE_TIMEOUT_MS)}ms`, this.loggingState.minimumLevel);
+                logToMcp(server, 'warning', `Client did not send notifications/initialized within ${String(initHandshakeTimeoutMs)}ms`, this.loggingState.minimumLevel);
                 onInitTimeout?.();
             }
             this.initTimer = undefined;
-        }, INIT_HANDSHAKE_TIMEOUT_MS);
+        }, initHandshakeTimeoutMs);
         this.initTimer.unref();
     }
     async recomputeAllowedDirectories() {

package/dist/tools/apply-patch.js

@@ -1,10 +1,10 @@
-import { readFile, stat } from 'node:fs/promises';
+import { stat } from 'node:fs/promises';
 import { basename, resolve } from 'node:path';
 import { applyPatch, parsePatch } from 'diff';
 import { withAbort } from '../lib/abort.js';
 import { MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
-import { atomicWriteFile, processInParallel } from '../lib/fs-helpers.js';
+import { atomicWriteFile, processInParallel, readFileWithStats, } from '../lib/fs-helpers.js';
 import { Logger } from '../lib/logger.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
@@ -62,7 +62,12 @@ async function applyDiff(filePath, diff, options, signal) {
     assertAllowedFileAccess(filePath, validPath);
     const stats = await withAbort(stat(validPath), signal);
     assertPatchTargetSizeWithinLimit(validPath, stats.size, MAX_TEXT_FILE_SIZE);
-    const content = await readFile(validPath, { encoding: 'utf-8', signal });
+    const { content } = await readFileWithStats(filePath, validPath, stats, {
+        encoding: 'utf-8',
+        maxSize: MAX_TEXT_FILE_SIZE,
+        skipBinary: true,
+        ...(signal ? { signal } : {}),
+    });
     const patched = applyPatch(content, diff, {
         fuzzFactor: options.fuzzFactor,
         autoConvertLineEndings: options.autoConvertLineEndings,

package/dist/tools/edit-file.js

@@ -1,11 +1,11 @@
-import { readFile, stat } from 'node:fs/promises';
+import { stat } from 'node:fs/promises';
 import { basename } from 'node:path';
 import { createTwoFilesPatch, diffLines } from 'diff';
 import RE2 from 're2';
 import { withAbort } from '../lib/abort.js';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
-import { atomicWriteFile } from '../lib/fs-helpers.js';
+import { atomicWriteFile, readFileWithStats } from '../lib/fs-helpers.js';
 import { Logger } from '../lib/logger.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { EditFileInputSchema, EditFileOutputSchema } from '../schemas.js';
@@ -167,7 +167,12 @@ async function loadEditableFile(requestedPath, signal) {
     if (stats.size > MAX_TEXT_FILE_SIZE) {
         throw new McpError(ErrorCode.TOO_LARGE, `File too large for edit (${stats.size} bytes > ${MAX_TEXT_FILE_SIZE} bytes)`, requestedPath, { size: stats.size, maxFileSize: MAX_TEXT_FILE_SIZE });
     }
-    const content = await readFile(validPath, { encoding: 'utf-8', signal });
+    const { content } = await readFileWithStats(requestedPath, validPath, stats, {
+        encoding: 'utf-8',
+        maxSize: MAX_TEXT_FILE_SIZE,
+        skipBinary: true,
+        ...(signal ? { signal } : {}),
+    });
     return { validPath, content };
 }
 function buildEditProgressMessage(args) {

package/dist/tools/read.js

@@ -1,8 +1,7 @@
-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';
+import { calculateFileContentHash, readFile } from '../lib/fs-helpers.js';
 import { ReadFileInputSchema, ReadFileOutputSchema } from '../schemas.js';
 import { FILE_READ_ICONS } from './icons.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, maybeExternalizeTextContent, READ_ONLY_TOOL_ANNOTATIONS, } from './shared.js';
@@ -144,9 +143,7 @@ async function handleReadFile(args, signal, resourceStore) {
     const result = await readFile(args.path, options);
     const structured = toStructuredReadFileResult(args, result);
     if (args.includeHash) {
-        structured.contentHash = createHash('sha256')
-            .update(result.content, 'utf-8')
-            .digest('hex');
+        structured.contentHash = await calculateFileContentHash(result.path, signal);
     }
     const externalizedResponse = maybeBuildExternalizedReadResponse(args.path, result.content, structured, resourceStore);
     if (externalizedResponse) {

package/dist/tools/task-support.js

@@ -263,6 +263,19 @@ const TERMINAL_TASK_STATUSES = new Set([
     'cancelled',
     'unknown',
 ]);
+const taskCreationLocks = new WeakMap();
+async function acquireTaskCreationLock(taskStore) {
+    const previous = taskCreationLocks.get(taskStore) ?? Promise.resolve();
+    let release;
+    const next = new Promise((resolve) => {
+        release = resolve;
+    });
+    taskCreationLocks.set(taskStore, previous.catch(() => { }).then(() => next));
+    await previous.catch(() => { });
+    return () => {
+        release();
+    };
+}
 async function isTaskAlreadyTerminal(taskStore, taskId) {
     try {
         const task = await taskStore.getTask(taskId);
@@ -443,13 +456,20 @@ export function createToolTaskHandler(run, options) {
             throw new McpError(ErrorCode.INVALID_INPUT, 'Client not initialized; wait for notifications/initialized');
         }
         const taskStore = getTaskStore(ctx);
-        if ((await countActiveTasks(taskStore)) >= MAX_CONCURRENT_TASKS) {
-            throw new McpError(ErrorCode.INVALID_INPUT, `Too many active tasks (limit: ${String(MAX_CONCURRENT_TASKS)}).`);
+        const releaseCreationLock = await acquireTaskCreationLock(taskStore);
+        let task;
+        try {
+            if ((await countActiveTasks(taskStore)) >= MAX_CONCURRENT_TASKS) {
+                throw new McpError(ErrorCode.INVALID_INPUT, `Too many active tasks (limit: ${String(MAX_CONCURRENT_TASKS)}).`);
+            }
+            task = await taskStore.createTask({
+                ttl: resolveRequestedTaskTtl(ctx.taskRequestedTtl),
+                pollInterval: options?.pollIntervalMs ?? TASK_POLL_INTERVAL_MS,
+            });
+        }
+        finally {
+            releaseCreationLock();
         }
-        const task = await taskStore.createTask({
-            ttl: resolveRequestedTaskTtl(ctx.taskRequestedTtl),
-            pollInterval: options?.pollIntervalMs ?? TASK_POLL_INTERVAL_MS,
-        });
         const toolLabel = options?.toolName ?? 'tool';
         try {
             await taskStore.updateTaskStatus(task.taskId, 'working', `${toolLabel}: starting`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.17.0",
+  "version": "1.17.1",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "Secure filesystem MCP server for reading, writing, searching, diffing, and patching files.",
   "author": "j0hanz",