@j0hanz/filesystem-mcp 1.13.2 → 1.14.1

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

@@ -50,22 +50,21 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import * as fsp from 'node:fs/promises';
-import * as path from 'node:path';
 import { AsyncResource } from 'node:async_hooks';
-import { existsSync } from 'node:fs';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { open, stat } from 'node:fs/promises';
+import { basename, dirname } from 'node:path';
 import { debuglog } from 'node:util';
 import { parentPort, threadId, Worker, workerData } from 'node:worker_threads';
 import RE2 from 're2';
-import safeRegex from 'safe-regex2';
 import { z } from 'zod';
+import { assertNotAborted, withAbort, withTimedAbortSignal } from '../abort.js';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_MAX_FILES, DEFAULT_SEARCH_TIMEOUT_MS, MAX_LINE_CONTENT_LENGTH, MAX_SEARCHABLE_FILE_SIZE, SEARCH_WORKERS, } from '../constants.js';
 import { ErrorCode, formatUnknownErrorMessage, isTimeoutLikeError, McpError, } from '../errors.js';
-import { assertNotAborted, isProbablyBinary, withAbort, withTimedAbortSignal, } from '../fs-helpers.js';
+import { isProbablyBinary } from '../fs-helpers.js';
+import { isSafeGlobPattern } from '../globs.js';
 import { startPerfMeasure } from '../observability.js';
 import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../paths.js';
-import { mergeOptions, omitOptionKeys, reportPeriodicProgress, } from '../utils.js';
+import { mergeOptions, omitOptionKeys } from '../utils.js';
 import { compareOptionalNumberDesc, compareStringValues, isEntryAccessibleByType, isIgnoredByGitignore, loadRootGitignore, needsStatsForSort, resolveEntryType, resolveStopReason, stableSortByDerivedString, withOptionalStoppedReason, } from './core.js';
 import { buildGlobOptions, globEntries } from './traversal.js';
 function countRegexLineMatches(regex, line) {
@@ -85,20 +84,10 @@ function buildRegexPattern(pattern, options) {
     const escaped = options.isLiteral ? escapeLiteral(pattern) : pattern;
     return options.wholeWord ? `\\b${escaped}\\b` : escaped;
 }
-function validatePattern(pattern, options) {
-    if (options.isLiteral && pattern.length === 0)
-        return;
-    if (options.isLiteral && !options.wholeWord)
-        return;
-    const final = buildRegexPattern(pattern, options);
-    if (!safeRegex(final)) {
-        throw new Error(`Potentially unsafe regular expression (ReDoS risk): ${pattern}`);
-    }
-}
 function buildLiteralMatcher(pattern, options) {
     if (!options.caseSensitive) {
         const final = escapeLiteral(pattern);
-        const regex = new RegExp(final, 'gi');
+        const regex = new RE2(final, 'gi');
         return (line) => countRegexLineMatches(regex, line);
     }
     // Fast path for case-sensitive literal
@@ -117,10 +106,8 @@ function buildLiteralMatcher(pattern, options) {
         return count;
     };
 }
-function buildRegexMatcher(final, caseSensitive, multiline) {
-    let flags = caseSensitive ? 'g' : 'gi';
-    if (multiline)
-        flags += 'm';
+function buildRegexMatcher(final, caseSensitive) {
+    const flags = caseSensitive ? 'g' : 'gi';
     const regex = new RE2(final, flags);
     return (line) => countRegexLineMatches(regex, line);
 }
@@ -132,13 +119,19 @@ function buildMatcher(pattern, options) {
         return buildLiteralMatcher(pattern, options);
     }
     const final = buildRegexPattern(pattern, options);
-    validatePattern(pattern, options); // Re-validate to be safe
-    return buildRegexMatcher(final, options.caseSensitive, options.multiline);
+    return buildRegexMatcher(final, options.caseSensitive);
 }
 // --- Configuration & Schemas ---
 const SEARCH_CONTENT_MAX_RESULTS = 500;
+const SafeFilePatternSchema = z
+    .string()
+    .min(1, 'Pattern required')
+    .max(1000, 'Max 1000 chars')
+    .refine((value) => isSafeGlobPattern(value), {
+    error: 'Invalid glob or unsafe path (absolute/.. forbidden)',
+});
 const SearchOptionsSchema = z.strictObject({
-    filePattern: z.string().min(1),
+    filePattern: SafeFilePatternSchema,
     excludePatterns: z.array(z.string()),
     caseSensitive: z.boolean(),
     maxResults: z.int().min(0),
@@ -149,7 +142,6 @@ const SearchOptionsSchema = z.strictObject({
     contextLines: z.int().min(0),
     wholeWord: z.boolean(),
     isLiteral: z.boolean(),
-    multiline: z.boolean(),
     includeHidden: z.boolean(),
     baseNameMatch: z.boolean(),
     caseSensitiveFileMatch: z.boolean(),
@@ -166,14 +158,12 @@ const DEFAULTS = {
     contextLines: 0,
     wholeWord: false,
     isLiteral: true,
-    multiline: false,
     includeHidden: false,
     baseNameMatch: false,
     caseSensitiveFileMatch: true,
 };
 const ERROR_SCAN_CANCELLED = 'Scan cancelled';
 const ERROR_WORKER_POOL_CLOSED = 'Worker pool closed';
-const SEARCH_PROGRESS_THROTTLE_MODULO = 25;
 const SEARCH_WORKER_NAME_PREFIX = 'filesystem-search';
 const SEARCH_WORKER_RESOURCE_TYPE = 'SearchWorkerTask';
 // --- Helpers ---
@@ -182,7 +172,7 @@ function resolveOptions(options) {
     const merged = mergeOptions(DEFAULTS, normalizedOptions);
     const result = SearchOptionsSchema.safeParse(merged);
     if (!result.success) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid search options: ${result.error.message}`, undefined, { errors: z.treeifyError(result.error) });
+        throw new McpError(ErrorCode.INVALID_INPUT, `Invalid search options:\n${z.prettifyError(result.error)}`, undefined, { errors: z.treeifyError(result.error) });
     }
     return result.data;
 }
@@ -258,9 +248,31 @@ class ContextBuffer {
 }
 function trimContent(line) {
     return line.length > MAX_LINE_CONTENT_LENGTH
-        ? line.slice(0, MAX_LINE_CONTENT_LENGTH)
+        ? `${line.slice(0, MAX_LINE_CONTENT_LENGTH)}\u2026`
         : line;
 }
+function processLineMatch(matches, rawLine, lineNumber, matchCount, requestedPath, ctx) {
+    const trimmedLine = trimContent(rawLine);
+    if (ctx) {
+        matches.push({
+            file: requestedPath,
+            line: lineNumber,
+            content: trimmedLine,
+            matchCount,
+            contextBefore: ctx.snapshotBefore(),
+            contextAfter: ctx.scheduleAfter(),
+        });
+    }
+    else {
+        matches.push({
+            file: requestedPath,
+            line: lineNumber,
+            content: trimmedLine,
+            matchCount,
+        });
+    }
+    return trimmedLine;
+}
 async function readMatches(handle, requestedPath, matcher, options, maxMatches, isCancelled, signal) {
     if (maxMatches <= 0) {
         return [];
@@ -278,26 +290,12 @@ async function readMatches(handle, requestedPath, matcher, options, maxMatches,
             if (isCancelled())
                 break;
             const matchCount = matcher(rawLine);
-            const trimmedLine = hasContext || matchCount > 0 ? trimContent(rawLine) : '';
+            let trimmedLine = '';
             if (matchCount > 0) {
-                if (ctx) {
-                    matches.push({
-                        file: requestedPath,
-                        line: lineNumber,
-                        content: trimmedLine,
-                        matchCount,
-                        contextBefore: ctx.snapshotBefore(),
-                        contextAfter: ctx.scheduleAfter(),
-                    });
-                }
-                else {
-                    matches.push({
-                        file: requestedPath,
-                        line: lineNumber,
-                        content: trimmedLine,
-                        matchCount,
-                    });
-                }
+                trimmedLine = processLineMatch(matches, rawLine, lineNumber, matchCount, requestedPath, ctx);
+            }
+            else if (hasContext) {
+                trimmedLine = trimContent(rawLine);
             }
             if (ctx) {
                 ctx.add(trimmedLine);
@@ -319,7 +317,7 @@ async function scanFileResolved(resolvedPath, requestedPath, matcher, options, s
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         assertNotAborted(signal);
-        const handle = __addDisposableResource(env_1, await withAbort(fsp.open(resolvedPath, 'r'), signal), true);
+        const handle = __addDisposableResource(env_1, await withAbort(open(resolvedPath, 'r'), signal), true);
         const stats = await withAbort(handle.stat(), signal);
         if (stats.size > options.maxFileSize) {
             return {
@@ -370,7 +368,6 @@ function buildMatcherOptions(opts) {
         caseSensitive: opts.caseSensitive,
         wholeWord: opts.wholeWord,
         isLiteral: opts.isLiteral,
-        multiline: opts.multiline,
     };
 }
 function applyScanOutcome(summary, outcome) {
@@ -405,7 +402,6 @@ function buildSearchContentResult(root, pattern, filePattern, matches, summary)
         skippedTooLarge: summary.skippedTooLarge,
         skippedBinary: summary.skippedBinary,
         skippedInaccessible: summary.skippedInaccessible,
-        linesSkippedDueToRegexTimeout: 0,
     };
     return {
         basePath: root,
@@ -415,12 +411,9 @@ function buildSearchContentResult(root, pattern, filePattern, matches, summary)
         summary: withOptionalStoppedReason(baseSummary, summary.stoppedReason),
     };
 }
-const currentDir = path.dirname(fileURLToPath(import.meta.url));
-const isSourceContext = currentDir.endsWith('src\\lib\\file-operations') ||
-    currentDir.endsWith('src/lib/file-operations');
-const WORKER_SCRIPT_PATH = path.join(currentDir, isSourceContext ? 'search-worker.ts' : 'search-worker.js');
-const WORKER_SCRIPT_URL = pathToFileURL(WORKER_SCRIPT_PATH);
-const hasWorkerScript = existsSync(WORKER_SCRIPT_PATH);
+const isSourceContext = import.meta.url.endsWith('.ts');
+const WORKER_SCRIPT_URL = new URL(import.meta.url);
+const hasWorkerScript = true;
 class SearchWorkerTaskResource extends AsyncResource {
     #settled = false;
     constructor() {
@@ -524,9 +517,21 @@ class SearchWorkerPool {
         if (this.closed)
             throw new Error(ERROR_WORKER_POOL_CLOSED);
         const id = this.nextRequestId++;
-        const workerIndex = this.workerRoundRobin % this.size;
+        let workerIndex = 0;
+        const workerPendingCounts = new Array(this.size).fill(0);
+        for (const p of this.pending.values()) {
+            const idx = p.workerIndex;
+            workerPendingCounts[idx] = (workerPendingCounts[idx] ?? 0) + 1;
+        }
+        let minPending = workerPendingCounts[0] ?? 0;
+        for (let i = 1; i < this.size; i++) {
+            const pendingCount = workerPendingCounts[i] ?? 0;
+            if (pendingCount < minPending) {
+                minPending = pendingCount;
+                workerIndex = i;
+            }
+        }
         const worker = this.getWorker(workerIndex);
-        this.workerRoundRobin++;
         const promise = new Promise((resolve, reject) => {
             const resource = new SearchWorkerTaskResource();
             const pendingRequest = {
@@ -764,7 +769,7 @@ async function searchSingleFile(details, opts, pattern, signal) {
     }, signal, opts.maxResults);
     if (result.matched)
         summary.filesMatched = 1;
-    return buildSearchContentResult(path.dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
+    return buildSearchContentResult(dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
 }
 async function searchDirectory(details, opts, pattern, signal, onProgress) {
     const root = await validateExistingDirectory(details.resolvedPath, signal);
@@ -781,12 +786,12 @@ async function searchDirectory(details, opts, pattern, signal, onProgress) {
         stats: false,
         suppressErrors: true,
     }));
+    const summary = createScanSummary();
     async function* fileGenerator() {
-        let scanned = 0;
         for await (const entry of stream) {
             if (signal.aborted)
                 break;
-            if (scanned >= opts.maxFilesScanned)
+            if (summary.filesScanned >= opts.maxFilesScanned)
                 break;
             if (!entry.dirent.isFile())
                 continue;
@@ -795,36 +800,25 @@ async function searchDirectory(details, opts, pattern, signal, onProgress) {
                 continue;
             if (isSensitivePath(entry.path, normalized))
                 continue;
-            scanned++;
-            reportPeriodicProgress(onProgress, scanned, {
+            summary.filesScanned++;
+            onProgress?.({
+                current: summary.filesScanned,
                 total: opts.maxFilesScanned,
-                throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
             });
             yield { resolvedPath: normalized, requestedPath: entry.path };
         }
-        reportPeriodicProgress(onProgress, scanned, {
-            total: opts.maxFilesScanned,
-            throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
-            force: true,
-        });
-    }
-    const summary = createScanSummary();
-    const resolvedStream = fileGenerator();
-    async function* countingStream() {
-        for await (const f of resolvedStream) {
-            summary.filesScanned++;
-            yield f;
-        }
         if (summary.filesScanned >= opts.maxFilesScanned) {
             summary.truncated = true;
             summary.stoppedReason = 'maxFiles';
         }
+        onProgress?.({
+            current: summary.filesScanned,
+            total: opts.maxFilesScanned,
+        });
     }
-    const matcherOpts = buildMatcherOptions(opts);
-    validatePattern(pattern, matcherOpts);
     const matches = shouldUseWorkers()
-        ? await executeParallel(countingStream(), pattern, opts, signal, summary)
-        : await executeSequential(countingStream(), pattern, opts, signal, summary);
+        ? await executeParallel(fileGenerator(), pattern, opts, signal, summary)
+        : await executeSequential(fileGenerator(), pattern, opts, signal, summary);
     return buildSearchContentResult(root, pattern, opts.filePattern, matches, summary);
 }
 function buildTimeoutSearchResult(basePath, pattern, filePattern) {
@@ -834,19 +828,19 @@ function buildTimeoutSearchResult(basePath, pattern, filePattern) {
 }
 export async function searchContent(basePath, pattern, options = {}) {
     if (!basePath.trim())
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'basePath required');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'basePath required');
     if (typeof pattern !== 'string')
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'pattern required');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'pattern required');
     const opts = resolveOptions(options);
     try {
         return await withTimedAbortSignal(options.signal, opts.timeoutMs, async (signal) => {
             const details = await validateExistingPathDetailed(basePath, signal);
-            const stats = await withAbort(fsp.stat(details.resolvedPath), signal);
+            const stats = await withAbort(stat(details.resolvedPath), signal);
             if (stats.isFile()) {
                 return searchSingleFile(details, opts, pattern, signal);
             }
             if (!stats.isDirectory()) {
-                throw new McpError(ErrorCode.E_INVALID_INPUT, 'Path must be file or directory', basePath);
+                throw new McpError(ErrorCode.INVALID_INPUT, 'Path must be file or directory', basePath);
             }
             return searchDirectory(details, opts, pattern, signal, options.onProgress);
         });
@@ -961,9 +955,9 @@ async function collectFromStream(stream, signal, context) {
         if (shouldStopCollecting(state, normalized, signal))
             break;
         state.filesScanned++;
-        reportPeriodicProgress(onProgress, state.filesScanned, {
+        onProgress?.({
+            current: state.filesScanned,
             total: normalized.maxFilesScanned,
-            throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
         });
         if (isEntryIgnoredByGitignore(gitignoreMatcher, root, entry.path, entry.relativePath)) {
             continue;
@@ -981,10 +975,9 @@ async function collectFromStream(stream, signal, context) {
         if (state.truncated)
             break;
     }
-    reportPeriodicProgress(onProgress, state.filesScanned, {
+    onProgress?.({
+        current: state.filesScanned,
         total: normalized.maxFilesScanned,
-        throttleModulo: SEARCH_PROGRESS_THROTTLE_MODULO,
-        force: true,
     });
 }
 function isEntryIgnoredByGitignore(matcher, root, entryPath, relativePath) {
@@ -1047,7 +1040,7 @@ const SORT_COMPARATORS = {
 };
 function sortSearchResults(results, sortBy) {
     if (sortBy === 'name') {
-        stableSortByDerivedString(results, (item) => path.basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
+        stableSortByDerivedString(results, (item) => basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
         return;
     }
     const comparator = SORT_COMPARATORS[sortBy];
@@ -1080,8 +1073,7 @@ function getMatcherCacheKey(pattern, options) {
     const cs = options.caseSensitive ? '1' : '0';
     const ww = options.wholeWord ? '1' : '0';
     const lit = options.isLiteral ? '1' : '0';
-    const ml = options.multiline ? '1' : '0';
-    return `${pattern}|${cs}|${ww}|${lit}|${ml}`;
+    return `${pattern}|${cs}|${ww}|${lit}`;
 }
 function getCachedMatcher(pattern, options) {
     const key = getMatcherCacheKey(pattern, options);

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

@@ -1,6 +1,5 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { glob as fsGlob } from 'node:fs/promises';
+import { glob as fsGlob, lstat, stat } from 'node:fs/promises';
+import { isAbsolute, relative, resolve } from 'node:path';
 import { getToolContextSnapshot, publishOpsTraceEnd, publishOpsTraceError, publishOpsTraceStart, shouldPublishOpsTrace, startPerfMeasure, } from '../observability.js';
 import { toPosixPath } from '../paths.js';
 import { isRecord } from '../utils.js';
@@ -96,7 +95,7 @@ function assertOptionsShape(options) {
     }
 }
 function normalizeOptions(options) {
-    const cwd = path.resolve(options.cwd);
+    const cwd = resolve(options.cwd);
     const normalizedPattern = normalizePattern(options.pattern, options.baseNameMatch);
     const patterns = options.includeHidden
         ? buildHiddenPatterns(normalizedPattern, options.maxDepth ?? DEFAULT_MAX_HIDDEN_DEPTH)
@@ -136,18 +135,16 @@ function isGlobDirentLike(value) {
 function resolveDirentBase(cwd, parentPath) {
     if (!parentPath)
         return cwd;
-    return path.isAbsolute(parentPath)
-        ? parentPath
-        : path.resolve(cwd, parentPath);
+    return isAbsolute(parentPath) ? parentPath : resolve(cwd, parentPath);
 }
 function resolveStringMatchPath(cwd, match) {
-    return path.isAbsolute(match) ? match : path.resolve(cwd, match);
+    return isAbsolute(match) ? match : resolve(cwd, match);
 }
 function* processDirentMatch(match, cwd, maxDepth, seen, onlyFiles) {
     const base = resolveDirentBase(cwd, match.parentPath);
-    const absolutePath = path.resolve(base, match.name);
+    const absolutePath = resolve(base, match.name);
     if (maxDepth !== undefined) {
-        const rel = path.relative(cwd, absolutePath);
+        const rel = relative(cwd, absolutePath);
         if (getRelativeDepth(rel) > maxDepth)
             return;
     }
@@ -170,12 +167,12 @@ async function resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followS
     seen.add(absolutePath);
     try {
         const stats = followSymlinks
-            ? await fs.stat(absolutePath)
-            : await fs.lstat(absolutePath);
+            ? await stat(absolutePath)
+            : await lstat(absolutePath);
         if (onlyFiles && !stats.isFile())
             return null;
         const entry = { path: absolutePath, dirent: stats };
-        if (!path.isAbsolute(match)) {
+        if (!isAbsolute(match)) {
             entry.relativePath = match;
         }
         if (returnStats)
@@ -190,12 +187,13 @@ async function resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followS
 }
 async function* processIterable(iterable, context) {
     const { cwd, maxDepth, seen, onlyFiles, followSymlinks, returnStats, suppressErrors, } = context;
-    const buffer = [];
+    let buffer = [];
     const flush = async function* () {
         if (buffer.length === 0)
             return;
         // Process buffer concurrently
-        const currentBuffer = buffer.splice(0, buffer.length);
+        const currentBuffer = buffer;
+        buffer = [];
         const results = await Promise.all(currentBuffer.map((match) => resolveStringMatch(match, cwd, maxDepth, seen, onlyFiles, followSymlinks, returnStats, suppressErrors)));
         for (const entry of results) {
             if (entry !== null)

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

@@ -1,13 +1,7 @@
-import * as fsp from 'node:fs/promises';
 import type { Stats } from 'node:fs';
+import { type FileHandle } from 'node:fs/promises';
 import type { FileType } from '../config.js';
-export declare function assertNotAborted(signal?: AbortSignal, message?: string): void;
-export declare function withAbort<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;
-export declare function createTimedAbortSignal(baseSignal: AbortSignal | undefined, timeoutMs?: number): {
-    signal: AbortSignal;
-    cleanup: () => void;
-};
-export declare function withTimedAbortSignal<T>(baseSignal: AbortSignal | undefined, timeoutMs: number | undefined, run: (signal: AbortSignal) => Promise<T>): Promise<T>;
+export { assertNotAborted, createTimedAbortSignal, withAbort, withTimedAbortSignal, } from './abort.js';
 interface ParallelResult<R> {
     results: R[];
     errors: {
@@ -18,7 +12,7 @@ interface ParallelResult<R> {
 export declare function processInParallel<T, R>(items: T[], processor: (item: T) => Promise<R>, concurrency?: number, signal?: AbortSignal): Promise<ParallelResult<R>>;
 export declare function getFileType(stats: Stats): FileType;
 export declare function isHidden(name: string): boolean;
-export declare function isProbablyBinary(filePath: string, existingHandle?: fsp.FileHandle, signal?: AbortSignal): Promise<boolean>;
+export declare function isProbablyBinary(filePath: string, existingHandle?: FileHandle, signal?: AbortSignal): Promise<boolean>;
 type ReadMode = 'head' | 'full' | 'range' | 'tail';
 interface ReadFileOptions {
     encoding?: BufferEncoding;
@@ -49,4 +43,3 @@ export declare function atomicWriteFile(filePath: string, content: string, optio
     encoding?: BufferEncoding;
     signal?: AbortSignal | undefined;
 }): Promise<void>;
-export {};