@j0hanz/filesystem-mcp 1.1.2 → 1.2.0

package/dist/lib/file-operations/search-worker.js

@@ -4,6 +4,7 @@ import { isProbablyBinary } from '../fs-helpers.js';
 import { startPerfMeasure } from '../observability.js';
 import { buildMatcher, scanFileInWorker } from './search-content.js';
 const matcherCache = new Map();
+const MAX_MATCHER_CACHE_SIZE = 100;
 function getMatcherCacheKey(pattern, options) {
     const cs = options.caseSensitive ? '1' : '0';
     const ww = options.wholeWord ? '1' : '0';
@@ -14,19 +15,25 @@ function getCachedMatcher(pattern, options) {
     const key = getMatcherCacheKey(pattern, options);
     const cached = matcherCache.get(key);
     if (cached) {
-        matcherCache.delete(key);
-        matcherCache.set(key, cached);
+        refreshMatcherCacheEntry(key, cached);
         return cached;
     }
     const matcher = buildMatcher(pattern, options);
+    refreshMatcherCacheEntry(key, matcher);
+    evictOldestMatcherIfNeeded();
+    return matcher;
+}
+function refreshMatcherCacheEntry(key, matcher) {
+    matcherCache.delete(key);
     matcherCache.set(key, matcher);
-    if (matcherCache.size > 100) {
-        const firstKey = matcherCache.keys().next().value;
-        if (firstKey !== undefined) {
-            matcherCache.delete(firstKey);
-        }
+}
+function evictOldestMatcherIfNeeded() {
+    if (matcherCache.size <= MAX_MATCHER_CACHE_SIZE)
+        return;
+    const firstKey = matcherCache.keys().next().value;
+    if (firstKey !== undefined) {
+        matcherCache.delete(firstKey);
     }
-    return matcher;
 }
 const cancelledRequests = new Set();
 const activeRequests = new Set();
@@ -45,6 +52,11 @@ function consumeCancelled(id) {
     cancelledRequests.delete(id);
     return true;
 }
+function markCancelledIfActive(id) {
+    if (activeRequests.has(id)) {
+        cancelledRequests.add(id);
+    }
+}
 function buildScanResponse(id, result) {
     return {
         type: 'result',
@@ -97,14 +109,12 @@ function handleMessage(message) {
             void handleScanRequest(message);
             break;
         case 'cancel':
-            if (activeRequests.has(message.id)) {
-                cancelledRequests.add(message.id);
-            }
+            markCancelledIfActive(message.id);
             break;
         case 'shutdown':
             shuttingDown = true;
             for (const id of activeRequests) {
-                cancelledRequests.add(id);
+                markCancelledIfActive(id);
             }
             maybeFinishShutdown();
             break;

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

@@ -1,10 +1,11 @@
 import * as path from 'node:path';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_TIMEOUT_MS, } from '../constants.js';
 import { createTimedAbortSignal } from '../fs-helpers.js';
+import { toPosixPath } from '../path-format.js';
 import { isSensitivePath } from '../path-policy.js';
 import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
 import { isIgnoredByGitignore, loadRootGitignore } from './gitignore.js';
-import { globEntries } from './glob-engine.js';
+import { globEntries, resolveEntryType } from './glob-engine.js';
 function toSafeNonNegativeInt(value, fallback) {
     if (typeof value !== 'number' || !Number.isFinite(value))
         return fallback;
@@ -31,23 +32,23 @@ function normalizeOptions(options) {
         timeoutMs: toSafePositiveInt(options.timeoutMs, DEFAULT_SEARCH_TIMEOUT_MS),
     };
 }
-function resolveEntryType(dirent) {
-    if (dirent.isDirectory())
-        return 'directory';
-    if (dirent.isSymbolicLink())
-        return 'symlink';
-    if (dirent.isFile())
-        return 'file';
-    return 'other';
-}
 function ensureParentNodes(rootNode, nodeByPath, relativePath) {
-    const normalized = relativePath.replace(/\\/gu, '/');
+    const normalized = toPosixPath(relativePath);
     if (normalized.length === 0 || normalized === '.')
         return rootNode;
-    const segments = normalized.split('/').filter((seg) => seg.length > 0);
+    const segments = [];
+    for (const segment of normalized.split('/')) {
+        if (segment.length > 0) {
+            segments.push(segment);
+        }
+    }
+    const parentSegmentCount = Math.max(0, segments.length - 1);
     let current = rootNode;
     let currentPath = '';
-    for (const segment of segments.slice(0, Math.max(0, segments.length - 1))) {
+    for (let index = 0; index < parentSegmentCount; index += 1) {
+        const segment = segments[index];
+        if (!segment)
+            continue;
         currentPath =
             currentPath.length === 0
                 ? segment
@@ -71,23 +72,24 @@ function ensureParentNodes(rootNode, nodeByPath, relativePath) {
 function sortTree(node) {
     if (!node.children)
         return;
-    node.children.sort((a, b) => {
-        const typeRank = (t) => {
-            if (t === 'directory')
-                return 0;
-            if (t === 'file')
-                return 1;
-            return 2;
-        };
-        const diff = typeRank(a.type) - typeRank(b.type);
-        if (diff !== 0)
-            return diff;
-        return a.name.localeCompare(b.name);
-    });
+    node.children.sort(compareTreeEntries);
     for (const child of node.children) {
         sortTree(child);
     }
 }
+function compareTreeEntries(a, b) {
+    const diff = getTreeTypeRank(a.type) - getTreeTypeRank(b.type);
+    if (diff !== 0)
+        return diff;
+    return a.name.localeCompare(b.name);
+}
+function getTreeTypeRank(type) {
+    if (type === 'directory')
+        return 0;
+    if (type === 'file')
+        return 1;
+    return 2;
+}
 function getStopReason(signal, totalEntries, maxEntries) {
     if (signal.aborted) {
         return 'aborted';
@@ -97,11 +99,11 @@ function getStopReason(signal, totalEntries, maxEntries) {
     }
     return undefined;
 }
-async function resolveTreeEntry(entry, root, rootNormalized, gitignoreMatcher, signal) {
+async function resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher, signal) {
     const type = resolveEntryType(entry.dirent);
     if (type !== 'symlink') {
         const normalized = normalizePath(entry.path);
-        if (!isPathWithinDirectories(normalized, [rootNormalized])) {
+        if (!isPathWithinDirectories(normalized, rootDirectories)) {
             return null;
         }
         if (isSensitivePath(entry.path, normalized)) {
@@ -126,7 +128,7 @@ async function resolveTreeEntry(entry, root, rootNormalized, gitignoreMatcher, s
         return null;
     }
     const relative = path.relative(root, entry.path) || path.basename(entry.path);
-    const relativePosix = relative.replace(/\\/gu, '/');
+    const relativePosix = toPosixPath(relative);
     const name = path.basename(entry.path);
     return { type, relativePosix, name };
 }
@@ -154,7 +156,10 @@ function upsertChildNode(parent, nodeByPath, resolved, childPathIndexByParent) {
         parent.children ??= [];
         let seen = childPathIndexByParent.get(parent);
         if (!seen) {
-            seen = new Set(parent.children.map((entry) => entry.relativePath));
+            seen = new Set();
+            for (const entry of parent.children) {
+                seen.add(entry.relativePath);
+            }
             childPathIndexByParent.set(parent, seen);
         }
         const key = child.relativePath;
@@ -201,9 +206,12 @@ export function formatTreeAscii(tree) {
             nextPrefix = `${prefix}${continuation}`;
         }
         const count = node.children.length;
-        node.children.forEach((child, index) => {
-            walk(child, nextPrefix, index === count - 1, false);
-        });
+        for (let index = 0; index < count; index += 1) {
+            const child = node.children[index];
+            if (child) {
+                walk(child, nextPrefix, index === count - 1, false);
+            }
+        }
     };
     walk(tree, '', true, true);
     return lines.join('\n');
@@ -213,6 +221,7 @@ export async function treeDirectory(dirPath, options = {}) {
     const { signal, cleanup } = createTimedAbortSignal(options.signal, normalized.timeoutMs);
     const root = await validateExistingDirectory(dirPath, signal);
     const rootNormalized = normalizePath(root);
+    const rootDirectories = [rootNormalized];
     try {
         const excludePatterns = normalized.includeIgnored
             ? []
@@ -249,7 +258,7 @@ export async function treeDirectory(dirPath, options = {}) {
                 truncated = true;
                 break;
             }
-            const resolved = await resolveTreeEntry(entry, root, rootNormalized, gitignoreMatcher, signal);
+            const resolved = await resolveTreeEntry(entry, root, rootDirectories, gitignoreMatcher, signal);
             if (!resolved) {
                 continue;
             }

package/dist/lib/fs-helpers.js

@@ -11,11 +11,20 @@ import { validateExistingPath } from './path-validation.js';
 function createAbortError(message = 'Operation aborted') {
     return new DOMException(message, 'AbortError');
 }
+const SHARED_NOOP_SIGNAL = new AbortController().signal;
 function normalizeAbortReason(reason, message) {
     if (reason instanceof Error)
         return reason;
     return createAbortError(message);
 }
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function normalizeUnknownError(error) {
+    return error instanceof Error
+        ? error
+        : new Error(formatUnknownErrorMessage(error));
+}
 export function assertNotAborted(signal, message) {
     if (!signal)
         return;
@@ -83,15 +92,13 @@ export function withAbort(promise, signal) {
         })
             .catch((error) => {
             finish(() => {
-                reject(error instanceof Error
-                    ? error
-                    : new Error(formatUnknownErrorMessage(error)));
+                reject(normalizeUnknownError(error));
             });
         });
     });
 }
 export function createTimedAbortSignal(baseSignal, timeoutMs) {
-    const timeoutSignal = typeof timeoutMs === 'number' && Number.isFinite(timeoutMs)
+    const timeoutSignal = isFiniteNumber(timeoutMs)
         ? AbortSignal.timeout(timeoutMs)
         : undefined;
     if (baseSignal && timeoutSignal) {
@@ -109,8 +116,7 @@ export function createTimedAbortSignal(baseSignal, timeoutMs) {
     return createNoopSignal();
 }
 function createNoopSignal() {
-    const controller = new AbortController();
-    return { signal: controller.signal, cleanup: () => { } };
+    return { signal: SHARED_NOOP_SIGNAL, cleanup: () => { } };
 }
 function createForwardedSignal(baseSignal) {
     return { signal: baseSignal, cleanup: () => { } };
@@ -118,118 +124,56 @@ function createForwardedSignal(baseSignal) {
 function createParallelAbortError() {
     return createAbortError();
 }
-function createState(items, processor, concurrency, signal) {
-    return {
-        items,
-        processor,
-        concurrency,
-        results: [],
-        errors: [],
-        nextIndex: 0,
-        aborted: Boolean(signal?.aborted),
-        inFlight: new Set(),
-    };
-}
-function attachAbortListener(state, signal) {
-    if (!signal || signal.aborted)
-        return () => { };
-    const onAbort = () => {
-        state.aborted = true;
-    };
-    signal.addEventListener('abort', onAbort, { once: true });
-    return () => {
-        signal.removeEventListener('abort', onAbort);
-    };
-}
-function createAbortPromise(signal) {
-    if (!signal)
-        return { cleanup: () => { } };
-    if (signal.aborted)
-        return { abortPromise: Promise.resolve(), cleanup: () => { } };
-    let cleanup = () => { };
-    const abortPromise = new Promise((resolve) => {
-        const onAbort = () => {
-            resolve();
-        };
-        signal.addEventListener('abort', onAbort, { once: true });
-        cleanup = () => {
-            signal.removeEventListener('abort', onAbort);
-        };
-    });
-    return { abortPromise, cleanup };
-}
-function canStartNext(state) {
-    return (!state.aborted &&
-        state.inFlight.size < state.concurrency &&
-        state.nextIndex < state.items.length);
-}
-async function createTask(item, index, state) {
-    try {
-        const result = await state.processor(item);
-        state.results.push(result);
-    }
-    catch (reason) {
-        const error = reason instanceof Error
-            ? reason
-            : new Error(formatUnknownErrorMessage(reason));
-        state.errors.push({ index, error });
-    }
-}
-function queueNextTask(state) {
-    const index = state.nextIndex;
-    state.nextIndex += 1;
-    const item = state.items[index];
-    if (item === undefined)
-        return;
-    const task = createTask(item, index, state);
-    state.inFlight.add(task);
-    void task.finally(() => {
-        state.inFlight.delete(task);
-    });
-}
-function startNextTasks(state) {
-    while (canStartNext(state)) {
-        queueNextTask(state);
-    }
-}
-async function drainTasks(state, abortPromise) {
-    startNextTasks(state);
-    while (state.inFlight.size > 0) {
-        if (abortPromise) {
-            const nextTask = Promise.race(state.inFlight);
-            await Promise.race([nextTask, abortPromise]);
-        }
-        else {
-            await Promise.race(state.inFlight);
-        }
-        if (state.aborted)
-            break;
-        startNextTasks(state);
-    }
-    if (state.inFlight.size > 0) {
-        await Promise.allSettled(state.inFlight);
-    }
-}
 export async function processInParallel(items, processor, concurrency = PARALLEL_CONCURRENCY, signal) {
-    const { abortPromise, cleanup: cleanupAbortPromise } = createAbortPromise(signal);
-    if (items.length === 0) {
-        cleanupAbortPromise();
+    if (items.length === 0)
         return { results: [], errors: [] };
-    }
     const effectiveConcurrency = normalizeConcurrency(concurrency);
-    const state = createState(items, processor, effectiveConcurrency, signal);
-    const detachAbort = attachAbortListener(state, signal);
-    try {
-        await drainTasks(state, abortPromise);
-    }
-    finally {
-        detachAbort();
-        cleanupAbortPromise();
+    // Pre-allocate slots by index to guarantee input-order output.
+    const resultSlots = new Array(items.length);
+    const errors = [];
+    if (signal?.aborted)
+        throw createParallelAbortError();
+    let nextIndex = 0;
+    const next = async () => {
+        while (nextIndex < items.length) {
+            if (signal?.aborted)
+                throw createParallelAbortError();
+            const index = nextIndex++;
+            // Check again because another worker might have incremented past length
+            if (index >= items.length)
+                break;
+            const item = items[index];
+            try {
+                const result = await processor(item);
+                if (signal?.aborted)
+                    throw createParallelAbortError();
+                resultSlots[index] = result;
+            }
+            catch (error) {
+                if (signal?.aborted)
+                    throw createParallelAbortError();
+                errors.push({
+                    index,
+                    error: normalizeUnknownError(error),
+                });
+            }
+        }
+    };
+    const workerCount = Math.min(items.length, effectiveConcurrency);
+    const workers = new Array(workerCount);
+    for (let index = 0; index < workerCount; index += 1) {
+        workers[index] = next();
     }
-    if (state.aborted) {
+    await Promise.allSettled(workers);
+    if (signal?.aborted)
         throw createParallelAbortError();
+    const results = [];
+    for (const slot of resultSlots) {
+        if (slot !== undefined) {
+            results.push(slot);
+        }
     }
-    return { results: state.results, errors: state.errors };
+    return { results, errors };
 }
 export function getFileType(stats) {
     if (stats.isFile())
@@ -307,12 +251,6 @@ function validateReadOptions(options) {
     if (hasEnd && !hasStart) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'endLine requires startLine');
     }
-    if (options.startLine !== undefined && options.startLine < 1) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'startLine must be at least 1');
-    }
-    if (options.endLine !== undefined && options.endLine < 1) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'endLine must be at least 1');
-    }
     if (options.startLine !== undefined &&
         options.endLine !== undefined &&
         options.endLine < options.startLine) {
@@ -326,7 +264,6 @@ function normalizeOptions(options) {
         maxSize: Math.min(options.maxSize ?? MAX_TEXT_FILE_SIZE, MAX_TEXT_FILE_SIZE),
         skipBinary: options.skipBinary ?? false,
     };
-    assertPositiveSafeIntegerOption('maxSize', normalized.maxSize, 'maxSize must be at least 1');
     if (options.head !== undefined) {
         normalized.head = options.head;
     }
@@ -590,12 +527,12 @@ async function readFullResult(handle, validPath, filePath, stats, normalized) {
 async function readByMode(handle, validPath, filePath, stats, normalized) {
     const mode = resolveReadMode(normalized);
     if (mode === 'head') {
-        return await readHeadResult(handle, validPath, filePath, normalized);
+        return readHeadResult(handle, validPath, filePath, normalized);
     }
     if (mode === 'range') {
-        return await readRangeResult(handle, validPath, filePath, normalized);
+        return readRangeResult(handle, validPath, filePath, normalized);
     }
-    return await readFullResult(handle, validPath, filePath, stats, normalized);
+    return readFullResult(handle, validPath, filePath, stats, normalized);
 }
 function assertFileStats(filePath, stats) {
     if (!stats.isFile()) {
@@ -620,14 +557,14 @@ async function readFileWithStatsInternal(filePath, validPath, stats, normalized)
 }
 export async function readFileWithStats(filePath, validPath, stats, options = {}) {
     const normalized = prepareReadOptions(options);
-    return await readFileWithStatsInternal(filePath, validPath, stats, normalized);
+    return readFileWithStatsInternal(filePath, validPath, stats, normalized);
 }
 export async function readFile(filePath, options = {}) {
     const normalized = prepareReadOptions(options);
     const validPath = await validateExistingPath(filePath, normalized.signal);
     assertNotAborted(normalized.signal);
     const stats = await withAbort(fsp.stat(validPath), normalized.signal);
-    return await readFileWithStatsInternal(filePath, validPath, stats, normalized);
+    return readFileWithStatsInternal(filePath, validPath, stats, normalized);
 }
 export async function atomicWriteFile(filePath, content, options = {}) {
     const { encoding = 'utf-8', signal } = options;

package/dist/lib/observability.js

@@ -2,14 +2,16 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { hash } from 'node:crypto';
 import { channel, tracingChannel } from 'node:diagnostics_channel';
 import { monitorEventLoopDelay, performance, PerformanceObserver, } from 'node:perf_hooks';
+import { isRecord } from './type-guards.js';
 // --- Configuration ---
 const ENV = process.env;
+let _cachedConfig;
 function readConfig() {
-    return {
+    return (_cachedConfig ??= {
         enabled: isTrue(ENV['FS_CONTEXT_DIAGNOSTICS']),
         detail: parseDetail(ENV['FS_CONTEXT_DIAGNOSTICS_DETAIL']),
         logToolErrors: isTrue(ENV['FS_CONTEXT_TOOL_LOG_ERRORS']),
-    };
+    });
 }
 function isTrue(val) {
     const norm = val?.trim().toLowerCase();
@@ -47,11 +49,8 @@ const toolContext = new AsyncLocalStorage({
 let perfObserver;
 let traceCounter = 0;
 // --- Helpers: Result Analysis ---
-function isObject(v) {
-    return typeof v === 'object' && v !== null;
-}
 function extractOutcome(result) {
-    if (!isObject(result)) {
+    if (!isRecord(result)) {
         return { ok: true };
     }
     if (result['isError'] === true) {
@@ -64,7 +63,7 @@ function extractOutcome(result) {
         return { ok: false, error: extractErrorMessage(result) };
     }
     const content = result['structuredContent'];
-    if (isObject(content) && typeof content['ok'] === 'boolean') {
+    if (isRecord(content) && typeof content['ok'] === 'boolean') {
         if (content['ok'])
             return { ok: true };
         const err = extractResultError(content);
@@ -77,17 +76,17 @@ function extractErrorMessage(source) {
         return source;
     if (source instanceof Error)
         return source.message;
-    if (isObject(source)) {
+    if (isRecord(source)) {
         const struct = source['structuredContent'];
-        if (isObject(struct)) {
+        if (isRecord(struct)) {
             const err = struct['error'];
-            if (isObject(err) && typeof err['message'] === 'string')
+            if (isRecord(err) && typeof err['message'] === 'string')
                 return err['message'];
         }
         if (typeof source['message'] === 'string')
             return source['message'];
         const errObj = source['error'];
-        if (isObject(errObj) && typeof errObj['message'] === 'string') {
+        if (isRecord(errObj) && typeof errObj['message'] === 'string') {
             return errObj['message'];
         }
     }
@@ -100,7 +99,7 @@ function extractErrorMessage(source) {
 }
 function extractResultError(structured) {
     const err = structured['error'];
-    return isObject(err) && typeof err['message'] === 'string'
+    return isRecord(err) && typeof err['message'] === 'string'
         ? err['message']
         : undefined;
 }
@@ -216,6 +215,10 @@ function normalizeContext(ctx) {
     }
     return { ...ctx, path: normalized };
 }
+function clearMeasureMarks(startMark, endMark) {
+    performance.clearMarks(startMark);
+    performance.clearMarks(endMark);
+}
 export function startPerfMeasure(name, detail) {
     if (!readConfig().enabled || !CHANNELS.perf.hasSubscribers)
         return undefined;
@@ -245,14 +248,12 @@ export function startPerfMeasure(name, detail) {
                     });
                 }
                 finally {
-                    performance.clearMarks(startMark);
-                    performance.clearMarks(endMark);
+                    clearMeasureMarks(startMark, endMark);
                 }
             });
         }
         catch {
-            performance.clearMarks(startMark);
-            performance.clearMarks(endMark);
+            clearMeasureMarks(startMark, endMark);
         }
     };
 }
@@ -291,15 +292,15 @@ async function runAndObserve(tool, run, pubTool, pubPerf, logErrors, pathVal) {
     if (pubTool)
         publishToolStart(tool, pathVal);
     let result;
-    let ok = false;
-    let errorMsg;
+    const obs = { ok: false, errorMsg: undefined };
     try {
         result = await run();
-        ({ ok, error: errorMsg } = extractOutcome(result));
+        const { ok, error } = extractOutcome(result);
+        obs.ok = ok;
+        obs.errorMsg = error;
     }
     catch (err) {
-        ok = false;
-        errorMsg = extractErrorMessage(err);
+        obs.errorMsg = extractErrorMessage(err);
         throw err;
     }
     finally {
@@ -308,10 +309,10 @@ async function runAndObserve(tool, run, pubTool, pubPerf, logErrors, pathVal) {
         if (pubPerf && eluStart)
             publishPerfEnd(tool, durationMs, eluStart, loopMonitor);
         if (pubTool)
-            publishToolEnd(tool, ok, durationMs, errorMsg);
-        updateMetrics(tool, ok, durationMs);
-        if (logErrors && !ok)
-            logError(tool, durationMs, errorMsg);
+            publishToolEnd(tool, obs.ok, durationMs, obs.errorMsg);
+        updateMetrics(tool, obs.ok, durationMs);
+        if (logErrors && !obs.ok)
+            logError(tool, durationMs, obs.errorMsg);
     }
     return result;
 }
@@ -322,10 +323,10 @@ export async function withToolDiagnostics(tool, run, options) {
         tool,
         ...(options?.path ? { path: options.path } : {}),
     };
-    return await toolContext.run(context, async () => {
+    return toolContext.run(context, async () => {
         if (!config.enabled) {
             if (!config.logToolErrors)
-                return await run();
+                return run();
             const start = performance.now();
             try {
                 const res = await run();
@@ -356,7 +357,7 @@ export async function withToolDiagnostics(tool, run, options) {
                 throw e;
             }
         }
-        return await runAndObserve(tool, run, pubTool, pubPerf, config.logToolErrors, normalizedPath);
+        return runAndObserve(tool, run, pubTool, pubPerf, config.logToolErrors, normalizedPath);
     });
 }
 function logError(tool, durationMs, msg) {

package/dist/lib/path-format.d.ts

@@ -0,0 +1 @@
+export declare function toPosixPath(value: string): string;

package/dist/lib/path-format.js

@@ -0,0 +1,7 @@
+const WINDOWS_PATH_SEPARATOR = '\\';
+const POSIX_PATH_SEPARATOR = '/';
+export function toPosixPath(value) {
+    return value.includes(WINDOWS_PATH_SEPARATOR)
+        ? value.replace(/\\/gu, POSIX_PATH_SEPARATOR)
+        : value;
+}