@j0hanz/filesystem-mcp 1.11.0 → 1.12.0

package/dist/completions.js

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 import { CompleteRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { getAllowedDirectories, isPathWithinDirectories, normalizePath, toPosixPath, } from './lib/paths.js';
 import { isRecord } from './lib/utils.js';
+import { getSortedToolContracts } from './resources/tool-info.js';
 const MAX_COMPLETION_ITEMS = 100;
 const COMPLETION_RATE_LIMIT_MS = 100;
 const MAX_COMPLETION_CACHE_KEYS = 128;
@@ -29,6 +30,9 @@ function extractTopicCompletions(instructions) {
     }
     return headers;
 }
+function extractToolNameCompletions() {
+    return getSortedToolContracts().map((contract) => contract.name);
+}
 const PATH_ARGUMENTS = new Set([
     'path',
     'source',
@@ -415,6 +419,7 @@ export async function getPathCompletions(currentValue, options = {}) {
 }
 export function registerCompletions(server, instructions = '') {
     const topicValues = extractTopicCompletions(instructions);
+    const toolNameValues = extractToolNameCompletions();
     server.server.setRequestHandler(CompleteRequestSchema, async (request) => {
         const { params } = request;
         const { argument, ref } = params;
@@ -427,6 +432,26 @@ export function registerCompletions(server, instructions = '') {
                 : topicValues;
             return buildCompletionResponse(buildCompletionResult(filtered));
         }
+        if (isRecord(ref) &&
+            ref['type'] === 'ref/prompt' &&
+            ref['name'] === 'get-tool-help' &&
+            argName === 'name') {
+            const currentValue = argument.value.toLowerCase();
+            const filtered = currentValue
+                ? toolNameValues.filter((value) => value.startsWith(currentValue))
+                : toolNameValues;
+            return buildCompletionResponse(buildCompletionResult(filtered));
+        }
+        if (isRecord(ref) &&
+            ref['type'] === 'ref/resource' &&
+            ref['uri'] === 'internal://tool-info/{name}' &&
+            argName === 'name') {
+            const currentValue = argument.value.toLowerCase();
+            const filtered = currentValue
+                ? toolNameValues.filter((value) => value.startsWith(currentValue))
+                : toolNameValues;
+            return buildCompletionResponse(buildCompletionResult(filtered));
+        }
         const isPathArg = isPathLikeArgumentName(argName) ||
             isPathArgumentFromReference(argName, ref);
         if (!isPathArg) {

package/dist/lib/constants.d.ts

@@ -3,6 +3,8 @@ export declare function parseEnvInt(envVar: string, defaultValue: number, min: n
 export declare const DEFAULT_LOG_LEVEL: "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
 export declare const REQUIRED_MCP_PROTOCOL_VERSION = "2025-11-25";
 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 PARALLEL_CONCURRENCY: number;
 export declare const MAX_SEARCHABLE_FILE_SIZE: number;
 export declare const MAX_TEXT_FILE_SIZE: number;

package/dist/lib/constants.js

@@ -73,6 +73,8 @@ export const DEFAULT_LOG_LEVEL = parseEnvLogLevel('FILESYSTEM_MCP_LOG_LEVEL', 'i
 export const REQUIRED_MCP_PROTOCOL_VERSION = '2025-11-25';
 // Default TTL for MCP tasks when the client does not specify one (5 minutes).
 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);
 // Auto-tuned parallelism based on CPU cores (no env override)
 const BYTES_PER_PARALLEL_TASK = 64 * MIB;
 const BYTES_PER_SEARCH_WORKER = 128 * MIB;

package/dist/lib/file-operations/metadata.js

@@ -6,6 +6,12 @@ import { assertNotAborted, getFileType, isHidden, processInParallel, readFile, r
 import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, normalizePath, toPosixPath, validateExistingDirectory, validateExistingPath, validateExistingPathDetailed, } from '../paths.js';
 import { applyIndexedErrors, applyIndexedValues, isEntryAccessibleByType, isIgnoredByGitignore, loadRootGitignore, needsStatsForSort, resolveEntryType, resolveStopReason, withOptionalStoppedReason, } from './core.js';
 import { globEntries } from './traversal.js';
+const ACCESS_DEPS = {
+    normalizePath,
+    isPathWithinDirectories,
+    isSensitivePath,
+    validateSymlinkPath: validateExistingPathDetailed,
+};
 const PERM_STRINGS = [
     '---',
     '--x',
@@ -18,13 +24,9 @@ const PERM_STRINGS = [
 ];
 const UNKNOWN_PATH = '(unknown)';
 function getPermissions(mode) {
-    const ownerIndex = (mode >> 6) & 0b111;
-    const groupIndex = (mode >> 3) & 0b111;
-    const otherIndex = mode & 0b111;
-    const owner = PERM_STRINGS[ownerIndex] ?? '---';
-    const group = PERM_STRINGS[groupIndex] ?? '---';
-    const other = PERM_STRINGS[otherIndex] ?? '---';
-    return `${owner}${group}${other}`;
+    return ((PERM_STRINGS[(mode >> 6) & 0b111] ?? '---') +
+        (PERM_STRINGS[(mode >> 3) & 0b111] ?? '---') +
+        (PERM_STRINGS[mode & 0b111] ?? '---'));
 }
 function buildFileInfoResult(name, requestedPath, isSymlink, stats, mimeType, symlinkTarget) {
     const tokenEstimate = stats.isFile() ? Math.ceil(stats.size / 4) : undefined;
@@ -59,8 +61,8 @@ export async function getFileInfo(filePath, options = {}) {
     assertNotAborted(signal);
     const { requestedPath, resolvedPath, isSymlink } = await validateExistingPathDetailed(filePath, signal);
     assertAllowedFileAccess(requestedPath, resolvedPath);
-    const name = path.basename(requestedPath);
-    const ext = path.extname(name).toLowerCase();
+    const { base: name, ext: rawExt } = path.parse(requestedPath);
+    const ext = rawExt.toLowerCase();
     const includeMimeType = options.includeMimeType !== false;
     const mimeType = includeMimeType && ext.length > 0 ? getMimeType(ext) : undefined;
     const symlinkTarget = isSymlink
@@ -75,25 +77,21 @@ function buildEmptyResult() {
         summary: { total: 0, succeeded: 0, failed: 0, totalSize: 0 },
     };
 }
-async function processFileInfo(filePath, options) {
-    const info = await getFileInfo(filePath, options);
-    return { path: filePath, info };
-}
 function buildIndexedPathTasks(paths) {
     const tasks = [];
     for (let index = 0; index < paths.length; index += 1) {
         const filePath = paths[index];
-        if (filePath === undefined)
-            continue;
-        tasks.push({ filePath, index });
+        if (filePath !== undefined) {
+            tasks.push({ filePath, index });
+        }
     }
     return tasks;
 }
 async function readFileInfoInParallel(paths, options) {
     return processInParallel(buildIndexedPathTasks(paths), async ({ filePath, index }) => {
-        const value = await processFileInfo(filePath, options);
+        const info = await getFileInfo(filePath, options);
         options.onProgress?.();
-        return { index, value };
+        return { index, value: { path: filePath, info } };
     }, PARALLEL_CONCURRENCY, options.signal);
 }
 function calculateSummary(results) {
@@ -119,10 +117,9 @@ function calculateSummary(results) {
 export async function getMultipleFileInfo(paths, options = {}) {
     if (paths.length === 0)
         return buildEmptyResult();
-    const output = new Array(paths.length);
-    for (let index = 0; index < paths.length; index += 1) {
-        output[index] = { path: paths[index] ?? UNKNOWN_PATH };
-    }
+    const output = Array.from(paths, (p) => ({
+        path: p,
+    }));
     const { results, errors } = await readFileInfoInParallel(paths, options);
     applyIndexedValues(output, results);
     applyIndexedErrors({
@@ -141,13 +138,7 @@ export async function getMultipleFileInfo(paths, options = {}) {
         summary: calculateSummary(output),
     };
 }
-function normalizePattern(pattern) {
-    if (!pattern || pattern.length === 0)
-        return undefined;
-    return pattern;
-}
 function normalizeListOptions(options) {
-    const pattern = normalizePattern(options.pattern);
     const normalized = {
         includeHidden: options.includeHidden ?? false,
         excludePatterns: options.excludePatterns ?? [],
@@ -156,71 +147,49 @@ function normalizeListOptions(options) {
         sortBy: options.sortBy ?? 'name',
         includeSymlinkTargets: options.includeSymlinkTargets ?? false,
         timeoutMs: options.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
-        ...(pattern !== undefined ? { pattern } : {}),
     };
+    if (options.pattern && options.pattern.length > 0) {
+        normalized.pattern = options.pattern;
+    }
     return normalized;
 }
+const SORT_COMPARATORS = {
+    name: (a, b) => a.name.localeCompare(b.name),
+    type: (a, b) => a.type.localeCompare(b.type),
+    size: (a, b) => (a.size ?? 0) - (b.size ?? 0),
+    modified: (a, b) => (a.modified?.getTime() ?? 0) - (b.modified?.getTime() ?? 0),
+};
 function sortEntries(entries, sortBy) {
-    const compare = {
-        name: (a, b) => a.name.localeCompare(b.name),
-        type: (a, b) => a.type.localeCompare(b.type),
-        size: (a, b) => (a.size ?? 0) - (b.size ?? 0),
-        modified: (a, b) => (a.modified?.getTime() ?? 0) - (b.modified?.getTime() ?? 0),
-    }[sortBy];
-    entries.sort(compare);
+    entries.sort(SORT_COMPARATORS[sortBy]);
 }
 function resolveMaxDepth(normalized) {
-    if (!normalized.pattern) {
-        return 1;
-    }
-    return normalized.maxDepth;
+    return normalized.pattern ? normalized.maxDepth : 1;
 }
 async function* readDirectoryEntries(basePath, normalized, needsStats, signal) {
     const dirents = await withAbort(fsp.readdir(basePath, { withFileTypes: true }), signal);
-    const entries = [];
-    for (const dirent of dirents) {
-        if (!normalized.includeHidden && isHidden(dirent.name)) {
-            continue;
-        }
-        entries.push({ dirent, entryPath: path.join(basePath, dirent.name) });
-    }
     if (!needsStats) {
-        for (const entry of entries) {
-            yield {
-                path: entry.entryPath,
-                dirent: entry.dirent,
-            };
+        for (const dirent of dirents) {
+            if (!normalized.includeHidden && isHidden(dirent.name))
+                continue;
+            yield { path: path.join(basePath, dirent.name), dirent };
         }
         return;
     }
-    const { results, errors } = await processInParallel(entries.map((_, index) => index), async (index) => {
-        const candidate = entries[index];
-        if (!candidate) {
-            throw new Error(`Entry index out of range: ${String(index)}`);
-        }
-        return {
-            index,
-            stats: await withAbort(fsp.lstat(candidate.entryPath), signal),
-        };
-    }, PARALLEL_CONCURRENCY, signal);
+    const filtered = [];
+    for (const dirent of dirents) {
+        if (!normalized.includeHidden && isHidden(dirent.name))
+            continue;
+        filtered.push({ dirent, entryPath: path.join(basePath, dirent.name) });
+    }
+    const { results, errors } = await processInParallel(filtered, async ({ entryPath, dirent }) => ({
+        path: entryPath,
+        dirent,
+        stats: await withAbort(fsp.lstat(entryPath), signal),
+    }), PARALLEL_CONCURRENCY, signal);
     if (errors.length > 0) {
         throw errors[0]?.error ?? new Error('Failed to read entry stats');
     }
-    const statsByIndex = [];
-    for (const result of results) {
-        statsByIndex[result.index] = result.stats;
-    }
-    for (let index = 0; index < entries.length; index += 1) {
-        const entry = entries[index];
-        if (!entry)
-            continue;
-        const stats = statsByIndex[index];
-        yield {
-            path: entry.entryPath,
-            dirent: entry.dirent,
-            ...(stats ? { stats } : {}),
-        };
-    }
+    yield* results;
 }
 function createEntryStream(basePath, normalized, maxDepth, needsStats, signal) {
     if (shouldUseFastPath(normalized, maxDepth)) {
@@ -286,13 +255,9 @@ async function enqueueAppendEntry(entry, entryType, ctx, pending, flushPending)
         appendEntry(entry, entryType, undefined, ctx);
         return;
     }
-    // Preserve the original behavior: resolve symlink targets in parallel
-    // when includeSymlinkTargets is enabled (bounded by PARALLEL_CONCURRENCY).
-    const task = (async () => {
-        const symlinkTarget = await resolveSymlinkTarget(entryType, ctx.includeSymlinkTargets, entry.path);
-        appendEntry(entry, entryType, symlinkTarget, ctx);
-    })();
-    pending.push(task);
+    pending.push(resolveSymlinkTarget(entryType, true, entry.path).then((target) => {
+        appendEntry(entry, entryType, target, ctx);
+    }));
     if (pending.length >= PARALLEL_CONCURRENCY) {
         await flushPending();
     }
@@ -316,12 +281,6 @@ async function collectEntries(basePath, normalized, signal, needsStats, maxDepth
     const totals = { files: 0, directories: 0 };
     const counters = { skippedInaccessible: 0, symlinksNotFollowed: 0 };
     const basePathDirectories = [basePath];
-    const accessDeps = {
-        normalizePath,
-        isPathWithinDirectories,
-        isSensitivePath,
-        validateSymlinkPath: validateExistingPathDetailed,
-    };
     let truncated = false;
     let stoppedReason;
     const pending = [];
@@ -354,7 +313,7 @@ async function collectEntries(basePath, normalized, signal, needsStats, maxDepth
         }
         const entryType = resolveEntryType(entry.dirent);
         trackSymlink(entryType, normalized.includeSymlinkTargets, counters);
-        const accessible = await isEntryAccessibleByType(entry.path, entryType, basePathDirectories, signal, accessDeps);
+        const accessible = await isEntryAccessibleByType(entry.path, entryType, basePathDirectories, signal, ACCESS_DEPS);
         if (!accessible) {
             counters.skippedInaccessible += 1;
             continue;
@@ -385,43 +344,27 @@ export async function listDirectory(dirPath, options = {}) {
         return { path: basePath, entries, summary };
     });
 }
-function toSafeNonNegativeInt(value, fallback) {
-    if (typeof value !== 'number' || !Number.isFinite(value))
-        return fallback;
-    const asInt = Math.floor(value);
-    return asInt >= 0 ? asInt : fallback;
-}
-function toSafePositiveInt(value, fallback) {
+function clampInt(value, fallback, min) {
     if (typeof value !== 'number' || !Number.isFinite(value))
         return fallback;
     const asInt = Math.floor(value);
-    return asInt > 0 ? asInt : fallback;
-}
-function toSafeBoolean(value, fallback) {
-    if (typeof value !== 'boolean')
-        return fallback;
-    return value;
+    return asInt >= min ? asInt : fallback;
 }
 function normalizeTreeOptions(options) {
     return {
-        maxDepth: toSafeNonNegativeInt(options.maxDepth, 5),
-        maxEntries: toSafeNonNegativeInt(options.maxEntries, 1000),
-        includeHidden: toSafeBoolean(options.includeHidden, false),
-        includeIgnored: toSafeBoolean(options.includeIgnored, false),
-        includeSizes: toSafeBoolean(options.includeSizes, false),
-        timeoutMs: toSafePositiveInt(options.timeoutMs, DEFAULT_SEARCH_TIMEOUT_MS),
+        maxDepth: clampInt(options.maxDepth, 5, 0),
+        maxEntries: clampInt(options.maxEntries, 1000, 0),
+        includeHidden: options.includeHidden ?? false,
+        includeIgnored: options.includeIgnored ?? false,
+        includeSizes: options.includeSizes ?? false,
+        timeoutMs: clampInt(options.timeoutMs, DEFAULT_SEARCH_TIMEOUT_MS, 1),
     };
 }
 function ensureParentNodes(rootNode, nodeByPath, relativePath) {
     const normalized = toPosixPath(relativePath);
     if (normalized.length === 0 || normalized === '.')
         return rootNode;
-    const segments = [];
-    for (const segment of normalized.split('/')) {
-        if (segment.length > 0) {
-            segments.push(segment);
-        }
-    }
+    const segments = normalized.split('/').filter(Boolean);
     const parentSegmentCount = Math.max(0, segments.length - 1);
     let current = rootNode;
     let currentPath = '';
@@ -430,9 +373,7 @@ function ensureParentNodes(rootNode, nodeByPath, relativePath) {
         if (!segment)
             continue;
         currentPath =
-            currentPath.length === 0
-                ? segment
-                : path.posix.join(currentPath, segment);
+            currentPath.length === 0 ? segment : `${currentPath}/${segment}`;
         let child = nodeByPath.get(currentPath);
         if (!child) {
             child = {
@@ -463,12 +404,9 @@ function compareTreeEntries(a, b) {
         return diff;
     return a.name.localeCompare(b.name);
 }
+const TREE_TYPE_RANKS = { directory: 0, file: 1 };
 function getTreeTypeRank(type) {
-    if (type === 'directory')
-        return 0;
-    if (type === 'file')
-        return 1;
-    return 2;
+    return TREE_TYPE_RANKS[type] ?? 2;
 }
 async function resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher, signal, accessDeps) {
     const type = resolveEntryType(entry.dirent);
@@ -482,8 +420,7 @@ async function resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher,
         })) {
         return null;
     }
-    const relative = path.relative(root, entry.path) || path.basename(entry.path);
-    const relativePosix = toPosixPath(relative);
+    const relativePosix = toPosixPath(resolveRelativePath(root, entry.path));
     const name = path.basename(entry.path);
     return { type, relativePosix, name };
 }
@@ -577,12 +514,6 @@ export async function treeDirectory(dirPath, options = {}) {
         const root = await validateExistingDirectory(dirPath, signal);
         const rootNormalized = normalizePath(root);
         const rootDirectories = [rootNormalized];
-        const accessDeps = {
-            normalizePath,
-            isPathWithinDirectories,
-            isSensitivePath,
-            validateSymlinkPath: validateExistingPathDetailed,
-        };
         const excludePatterns = normalized.includeIgnored
             ? []
             : DEFAULT_EXCLUDE_PATTERNS;
@@ -624,7 +555,7 @@ export async function treeDirectory(dirPath, options = {}) {
                 truncated = true;
                 break;
             }
-            const resolved = await resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher, signal, accessDeps);
+            const resolved = await resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher, signal, ACCESS_DEPS);
             if (!resolved) {
                 continue;
             }
@@ -727,12 +658,14 @@ function applyLineSelection(target, source) {
     if (source.endLine !== undefined)
         target.endLine = source.endLine;
 }
-function resolveListDirectoryNormalizedOptions(options) {
+function resolveNormalizedReadOptions(options) {
     const { signal, ...rest } = options;
-    return {
+    const result = {
         normalized: normalizeReadMultipleOptions(rest),
-        ...(signal ? { signal } : {}),
     };
+    if (signal)
+        result.signal = signal;
+    return result;
 }
 async function validateFile(filePath, index, signal) {
     const validPath = await validateExistingPath(filePath, signal);
@@ -818,11 +751,7 @@ async function collectFileBudget(filePaths, maxTotalSize, maxSize, signal) {
     return { skippedBudget, validated };
 }
 function buildOutput(filePaths) {
-    const output = new Array(filePaths.length);
-    for (let index = 0; index < filePaths.length; index += 1) {
-        output[index] = { path: filePaths[index] ?? UNKNOWN_PATH };
-    }
-    return output;
+    return Array.from(filePaths, (fp) => ({ path: fp }));
 }
 function resolveErrorOriginalIndex(failureIndex, filesToProcess, totalInputFiles) {
     // processInParallel implementations vary: some return error indices relative to
@@ -882,7 +811,7 @@ function applySkippedBudget(output, skippedBudget, filePaths, maxTotalSize) {
 export async function readMultipleFiles(filePaths, options = {}) {
     if (filePaths.length === 0)
         return [];
-    const { normalized, signal } = resolveListDirectoryNormalizedOptions(options);
+    const { normalized, signal } = resolveNormalizedReadOptions(options);
     const output = buildOutput(filePaths);
     const { skippedBudget, validated } = await collectFileBudget(filePaths, normalized.maxTotalSize, normalized.maxSize, signal);
     const filesToProcess = buildFilesToProcess(filePaths, validated, skippedBudget);