@j0hanz/filesystem-mcp 1.14.0 → 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
@@ -130,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);
 }
 // --- 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),
@@ -169,7 +164,6 @@ const DEFAULTS = {
 };
 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 ---
@@ -178,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:\n${z.prettifyError(result.error)}`, 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;
 }
@@ -254,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 [];
@@ -274,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);
@@ -315,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 {
@@ -409,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() {
@@ -518,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 = {
@@ -758,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);
@@ -775,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;
@@ -789,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) {
@@ -828,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);
         });
@@ -955,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;
@@ -975,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) {
@@ -1041,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];

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 {};

package/dist/lib/fs-helpers.js

@@ -50,36 +50,16 @@ 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 { isUtf8 } from 'node:buffer';
 import { randomUUID } from 'node:crypto';
+import { open, rename, stat, unlink, writeFile, } from 'node:fs/promises';
+import { extname } from 'node:path';
+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';
 import { assertAllowedFileAccess, validateExistingPath } from './paths.js';
-function createAbortError(message = 'Operation aborted') {
-    return new DOMException(message, 'AbortError');
-}
+export { assertNotAborted, createTimedAbortSignal, withAbort, withTimedAbortSignal, } from './abort.js';
 const READ_ONLY_FILE_FLAG = 'r';
-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);
-}
-export function assertNotAborted(signal, message) {
-    if (!signal)
-        return;
-    try {
-        signal.throwIfAborted();
-    }
-    catch (reason) {
-        throw normalizeAbortReason(reason, message);
-    }
-}
 function assertPositiveSafeIntegerOption(name, value, message) {
     if (value === undefined)
         return;
@@ -87,73 +67,15 @@ function assertPositiveSafeIntegerOption(name, value, message) {
         !Number.isFinite(value) ||
         !Number.isSafeInteger(value) ||
         value < 1) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, message ?? `${name} must be a positive integer`);
+        throw new McpError(ErrorCode.INVALID_INPUT, message ?? `${name} must be a positive integer`);
     }
 }
 function normalizeConcurrency(concurrency) {
     assertPositiveSafeIntegerOption('concurrency', concurrency);
     return concurrency;
 }
-function getAbortError(signal, message) {
-    try {
-        signal.throwIfAborted();
-    }
-    catch (reason) {
-        return normalizeAbortReason(reason, message);
-    }
-    return createAbortError(message);
-}
-export function withAbort(promise, signal) {
-    if (!signal)
-        return promise;
-    signal.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        const onAbort = () => {
-            reject(getAbortError(signal));
-        };
-        if (signal.aborted) {
-            onAbort();
-            return;
-        }
-        signal.addEventListener('abort', onAbort, { once: true });
-        promise.then((value) => {
-            signal.removeEventListener('abort', onAbort);
-            resolve(value);
-        }, (error) => {
-            signal.removeEventListener('abort', onAbort);
-            reject(normalizeUnknownError(error));
-        });
-    });
-}
-export function createTimedAbortSignal(baseSignal, timeoutMs) {
-    const timeoutSignal = isFiniteNumber(timeoutMs)
-        ? AbortSignal.timeout(timeoutMs)
-        : undefined;
-    if (baseSignal && timeoutSignal) {
-        return {
-            signal: AbortSignal.any([baseSignal, timeoutSignal]),
-            cleanup: () => { },
-        };
-    }
-    if (baseSignal) {
-        return { signal: baseSignal, cleanup: () => { } };
-    }
-    if (timeoutSignal) {
-        return { signal: timeoutSignal, cleanup: () => { } };
-    }
-    return { signal: SHARED_NOOP_SIGNAL, cleanup: () => { } };
-}
-export async function withTimedAbortSignal(baseSignal, timeoutMs, run) {
-    const { signal, cleanup } = createTimedAbortSignal(baseSignal, timeoutMs);
-    try {
-        return await run(signal);
-    }
-    finally {
-        cleanup();
-    }
-}
 function createParallelAbortError() {
-    return createAbortError();
+    return new DOMException('Operation aborted', 'AbortError');
 }
 export async function processInParallel(items, processor, concurrency = PARALLEL_CONCURRENCY, signal) {
     const itemCount = items.length;
@@ -218,11 +140,11 @@ export function isHidden(name) {
     return name.startsWith('.');
 }
 function hasKnownBinaryExtension(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
+    const ext = extname(filePath).toLowerCase();
     return KNOWN_BINARY_EXTENSIONS.has(ext);
 }
 async function openReadableFileHandle(filePath, signal) {
-    return withAbort(fsp.open(filePath, READ_ONLY_FILE_FLAG), signal);
+    return withAbort(open(filePath, READ_ONLY_FILE_FLAG), signal);
 }
 async function readProbe(handle, signal) {
     const buffer = Buffer.alloc(BINARY_CHECK_BUFFER_SIZE);
@@ -282,15 +204,15 @@ function validateReadOptions(options) {
     assertPositiveSafeIntegerOption('startLine', options.startLine, 'startLine must be at least 1');
     assertPositiveSafeIntegerOption('endLine', options.endLine, 'endLine must be at least 1');
     if (hasHead && (hasStart || hasEnd)) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'head cannot be used together with startLine/endLine');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'head cannot be used together with startLine/endLine');
     }
     if (hasTail && (hasHead || hasStart || hasEnd)) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'tail cannot be used together with head/startLine/endLine');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'tail cannot be used together with head/startLine/endLine');
     }
     {
         const effectiveStart = options.startLine ?? 1;
         if (options.endLine !== undefined && options.endLine < effectiveStart) {
-            throw new McpError(ErrorCode.E_INVALID_INPUT, 'endLine must be greater than or equal to startLine (default: 1)');
+            throw new McpError(ErrorCode.INVALID_INPUT, 'endLine must be greater than or equal to startLine (default: 1)');
         }
     }
 }
@@ -345,7 +267,7 @@ function resolveReadMode(options) {
 }
 const STREAM_CHUNK_SIZE = 64 * 1024;
 function createTooLargeError(bytesRead, maxSize, requestedPath) {
-    return new McpError(ErrorCode.E_TOO_LARGE, `File exceeds maximum size (${bytesRead} > ${maxSize}): ${requestedPath}`, requestedPath, { size: bytesRead, maxSize });
+    return new McpError(ErrorCode.TOO_LARGE, `File exceeds size limit (${bytesRead} > ${maxSize} bytes)`, requestedPath, { size: bytesRead, maxSize });
 }
 async function readFileBufferWithLimit(handle, maxSize, requestedPath, signal) {
     const stream = handle.createReadStream({
@@ -521,19 +443,19 @@ async function assertNotBinary(validPath, filePath, normalized) {
     const isBinary = await isProbablyBinary(validPath, undefined, normalized.signal);
     if (!isBinary)
         return;
-    throw new McpError(ErrorCode.E_INVALID_INPUT, `Binary file detected: ${filePath}. Refusing to read as text.`, filePath);
+    throw new McpError(ErrorCode.INVALID_INPUT, 'Binary file detected.', filePath);
 }
 function assertSizeWithinLimit(size, maxSize, filePath) {
     if (size <= maxSize)
         return;
-    throw new McpError(ErrorCode.E_TOO_LARGE, `File too large: ${size} bytes (max: ${maxSize} bytes). Use head parameter to preview the first N lines.`, filePath, { size, maxSize });
+    throw new McpError(ErrorCode.TOO_LARGE, `File too large (${size} > ${maxSize} bytes). Use head to preview.`, filePath, { size, maxSize });
 }
 function requireReadOption(normalized, key, filePath) {
     const value = normalized[key];
     if (value !== undefined) {
         return value;
     }
-    throw new McpError(ErrorCode.E_INVALID_INPUT, `Missing ${key} option`, filePath);
+    throw new McpError(ErrorCode.INVALID_INPUT, `Missing ${key} option`, filePath);
 }
 async function executeHeadRead(context) {
     const head = requireReadOption(context.normalized, 'head', context.filePath);
@@ -604,7 +526,7 @@ async function readByMode(context) {
 }
 function assertFileStats(filePath, stats) {
     if (!stats.isFile()) {
-        throw new McpError(ErrorCode.E_NOT_FILE, `Not a file: ${filePath}`, filePath);
+        throw new McpError(ErrorCode.NOT_FILE, 'Not a regular file', filePath);
     }
 }
 async function readFileWithStatsInternal(filePath, validPath, stats, normalized) {
@@ -644,7 +566,7 @@ 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);
+    const stats = await withAbort(stat(validPath), normalized.signal);
     return readFileWithStatsInternal(filePath, validPath, stats, normalized);
 }
 export async function atomicWriteFile(filePath, content, options = {}) {
@@ -652,13 +574,13 @@ export async function atomicWriteFile(filePath, content, options = {}) {
     const tempPath = `${filePath}.${randomUUID()}.tmp`;
     try {
         assertNotAborted(signal);
-        await fsp.writeFile(tempPath, content, { encoding, signal });
-        await withAbort(fsp.rename(tempPath, filePath), signal);
+        await writeFile(tempPath, content, { encoding, signal });
+        await withAbort(rename(tempPath, filePath), signal);
     }
     catch (error) {
         // Attempt cleanup on error, but don't overwrite the original error
         try {
-            await fsp.unlink(tempPath).catch(() => { });
+            await unlink(tempPath).catch(() => { });
         }
         catch {
             // Ignore cleanup errors

package/dist/lib/globs.js

@@ -14,6 +14,6 @@ export function isSafeGlobPattern(value) {
 }
 export function assertSafeGlobPattern(value, message = 'Invalid glob or unsafe path (absolute/.. forbidden)') {
     if (!isSafeGlobPattern(value)) {
-        throw new McpError(ErrorCode.E_INVALID_PATTERN, message);
+        throw new McpError(ErrorCode.INVALID_PATTERN, message);
     }
 }