@j0hanz/filesystem-mcp 1.8.0 → 1.9.0

package/dist/lib/file-operations/{search-content.d.ts → search.d.ts}

@@ -1,7 +1,15 @@
 import * as fsp from 'node:fs/promises';
 import { z } from 'zod';
-import type { ContentMatch, SearchContentResult } from '../../config.js';
-import type { Matcher, MatcherOptions } from './search-matcher.js';
+import type { ContentMatch, SearchContentResult, SearchFilesResult } from '../../config.js';
+export declare const MatcherOptionsSchema: z.ZodObject<{
+    caseSensitive: z.ZodBoolean;
+    wholeWord: z.ZodBoolean;
+    isLiteral: z.ZodBoolean;
+}, z.core.$strict>;
+export type MatcherOptions = z.infer<typeof MatcherOptionsSchema>;
+export type Matcher = (line: string) => number;
+export declare function validatePattern(pattern: string, options: MatcherOptions): void;
+export declare function buildMatcher(pattern: string, options: MatcherOptions): Matcher;
 export interface ScanFileOptions {
     maxFileSize: number;
     skipBinary: boolean;
@@ -66,4 +74,29 @@ interface WorkerScanResult {
 }
 export declare function scanFileInWorker(resolvedPath: string, requestedPath: string, matcher: Matcher, options: ScanFileOptions, maxMatches: number, isCancelled: () => boolean, isBinaryDetector: BinaryDetector): Promise<WorkerScanResult>;
 export declare function searchContent(basePath: string, pattern: string, options?: SearchContentOptions): Promise<SearchContentResult>;
+type SortBy = 'name' | 'size' | 'modified' | 'path';
+interface SearchFilesOptions {
+    maxResults?: number;
+    sortBy?: SortBy;
+    maxDepth?: number;
+    maxFilesScanned?: number;
+    timeoutMs?: number;
+    baseNameMatch?: boolean;
+    skipSymlinks?: boolean;
+    includeHidden?: boolean;
+    respectGitignore?: boolean;
+    signal?: AbortSignal;
+    onProgress?: (progress: {
+        total?: number;
+        current: number;
+    }) => void;
+}
+interface Sortable {
+    name?: string;
+    size?: number;
+    modified?: Date;
+    path?: string;
+}
+export declare function sortSearchResults(results: Sortable[], sortBy: SortBy): void;
+export declare function searchFiles(basePath: string, pattern: string, excludePatterns?: readonly string[], options?: SearchFilesOptions): Promise<SearchFilesResult>;
 export {};

package/dist/lib/file-operations/{search-content.js → search.js}

@@ -1,21 +1,89 @@
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { Worker } from 'node:worker_threads';
+import { parentPort, threadId, Worker, workerData } from 'node:worker_threads';
+import RE2 from 're2';
+import safeRegex from 'safe-regex2';
 import { z } from 'zod';
 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 { mergeOptions, omitOptionKeys } from '../option-utils.js';
-import { assertAllowedFileAccess, isSensitivePath } from '../path-policy.js';
-import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
-import { reportPeriodicProgress } from '../progress-reporting.js';
-import { withOptionalStoppedReason } from './common.js';
-import { globEntries } from './glob-engine.js';
-import { buildGlobOptions } from './glob-helpers.js';
-import { buildMatcher, validatePattern } from './search-matcher.js';
+import { startPerfMeasure } from '../observability.js';
+import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../paths.js';
+import { mergeOptions, omitOptionKeys, reportPeriodicProgress, } from '../utils.js';
+import { compareOptionalNumberDesc, compareStringValues, isEntryAccessibleByType, isIgnoredByGitignore, loadRootGitignore, needsStatsForSort, resolveEntryType, resolveStopReason, stableSortByDerivedString, withOptionalStoppedReason, } from './core.js';
+import { buildGlobOptions, globEntries } from './traversal.js';
+export const MatcherOptionsSchema = z.strictObject({
+    caseSensitive: z.boolean(),
+    wholeWord: z.boolean(),
+    isLiteral: z.boolean(),
+});
+function countRegexLineMatches(regex, line) {
+    regex.lastIndex = 0;
+    let count = 0;
+    while (regex.exec(line) !== null) {
+        count++;
+        if (regex.lastIndex === 0)
+            regex.lastIndex++;
+    }
+    return count;
+}
+function escapeLiteral(pattern) {
+    return pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildRegexPattern(pattern, options) {
+    const escaped = options.isLiteral ? escapeLiteral(pattern) : pattern;
+    return options.wholeWord ? `\\b${escaped}\\b` : escaped;
+}
+export 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');
+        return (line) => countRegexLineMatches(regex, line);
+    }
+    // Fast path for case-sensitive literal
+    const needle = pattern;
+    if (needle.length === 0)
+        return () => 0;
+    return (line) => {
+        if (line.length === 0)
+            return 0;
+        let count = 0;
+        let pos = line.indexOf(needle);
+        while (pos !== -1) {
+            count++;
+            pos = line.indexOf(needle, pos + needle.length);
+        }
+        return count;
+    };
+}
+function buildRegexMatcher(final, caseSensitive) {
+    const regex = new RE2(final, caseSensitive ? 'g' : 'gi');
+    return (line) => countRegexLineMatches(regex, line);
+}
+export function buildMatcher(pattern, options) {
+    if (options.isLiteral && pattern.length === 0)
+        return () => 0;
+    if (options.isLiteral && !options.wholeWord) {
+        // fast path for simple literal search
+        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 INTERNAL_MAX_RESULTS = 500;
+const SEARCH_CONTENT_MAX_RESULTS = 500;
 const SearchOptionsSchema = z.strictObject({
     filePattern: z.string().min(1),
     excludePatterns: z.array(z.string()),
@@ -36,7 +104,7 @@ const DEFAULTS = {
     filePattern: '**/*',
     excludePatterns: DEFAULT_EXCLUDE_PATTERNS,
     caseSensitive: false,
-    maxResults: INTERNAL_MAX_RESULTS,
+    maxResults: SEARCH_CONTENT_MAX_RESULTS,
     maxFileSize: MAX_SEARCHABLE_FILE_SIZE,
     maxFilesScanned: DEFAULT_SEARCH_MAX_FILES,
     timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS,
@@ -252,7 +320,7 @@ function createScanSummary() {
         stoppedReason: undefined,
     };
 }
-function buildSearchResult(root, pattern, filePattern, matches, summary) {
+function buildSearchContentResult(root, pattern, filePattern, matches, summary) {
     const baseSummary = {
         filesScanned: summary.filesScanned,
         filesMatched: summary.filesMatched,
@@ -578,7 +646,7 @@ async function searchSingleFile(details, opts, pattern, signal) {
     }, signal, opts.maxResults);
     if (result.matched)
         summary.filesMatched = 1;
-    return buildSearchResult(path.dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
+    return buildSearchContentResult(path.dirname(details.resolvedPath), pattern, opts.filePattern, result.matches, summary);
 }
 async function searchDirectory(details, opts, pattern, signal, onProgress) {
     const root = await validateExistingDirectory(details.resolvedPath, signal);
@@ -643,12 +711,12 @@ async function searchDirectory(details, opts, pattern, signal, onProgress) {
     const matches = shouldUseWorkers()
         ? await executeParallel(countingStream(), pattern, opts, signal, summary)
         : await executeSequential(countingStream(), pattern, opts, signal, summary);
-    return buildSearchResult(root, pattern, opts.filePattern, matches, summary);
+    return buildSearchContentResult(root, pattern, opts.filePattern, matches, summary);
 }
 function buildTimeoutSearchResult(basePath, pattern, filePattern) {
     const timeoutSummary = createScanSummary();
     markTruncated(timeoutSummary, 'timeout');
-    return buildSearchResult(basePath, pattern, filePattern, [], timeoutSummary);
+    return buildSearchContentResult(basePath, pattern, filePattern, [], timeoutSummary);
 }
 export async function searchContent(basePath, pattern, options = {}) {
     if (!basePath.trim())
@@ -676,3 +744,333 @@ export async function searchContent(basePath, pattern, options = {}) {
         throw error;
     }
 }
+// Internal default for find tool - not exposed to MCP users
+const SEARCH_FILES_MAX_RESULTS = 1000;
+function normalizeSearchFilesOptions(options) {
+    const normalized = {
+        maxResults: options.maxResults ?? SEARCH_FILES_MAX_RESULTS,
+        sortBy: options.sortBy ?? 'path',
+        maxFilesScanned: options.maxFilesScanned ?? DEFAULT_SEARCH_MAX_FILES,
+        timeoutMs: options.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT_MS,
+        baseNameMatch: options.baseNameMatch ?? false,
+        skipSymlinks: options.skipSymlinks ?? true,
+        includeHidden: options.includeHidden ?? false,
+        respectGitignore: options.respectGitignore ?? false,
+    };
+    if (options.maxDepth !== undefined) {
+        normalized.maxDepth = options.maxDepth;
+    }
+    return normalized;
+}
+function buildSearchFilesResult(entry, entryType, needsStats) {
+    let resolvedType = 'other';
+    if (entryType === 'directory') {
+        resolvedType = 'directory';
+    }
+    else if (entryType === 'file') {
+        resolvedType = 'file';
+    }
+    const size = needsStats && entry.stats?.isFile() ? entry.stats.size : undefined;
+    const modified = needsStats ? entry.stats?.mtime : undefined;
+    return {
+        path: entry.path,
+        type: resolvedType,
+        ...(size !== undefined ? { size } : {}),
+        ...(modified !== undefined ? { modified } : {}),
+    };
+}
+function shouldStopCollecting(state, normalized, signal) {
+    const stopReason = resolveStopReason({
+        signal,
+        current: state.filesScanned,
+        max: normalized.maxFilesScanned,
+        abortedReason: 'timeout',
+        maxReason: 'maxFiles',
+    });
+    if (stopReason !== undefined) {
+        state.truncated = true;
+        state.stoppedReason = stopReason;
+        return true;
+    }
+    return false;
+}
+function shouldIncludeEntry(entryType, normalized) {
+    return !normalized.skipSymlinks || entryType !== 'symlink';
+}
+function createCollectState() {
+    return {
+        results: [],
+        filesScanned: 0,
+        truncated: false,
+        skippedInaccessible: 0,
+    };
+}
+function buildSearchStream(root, pattern, excludePatterns, normalized, needsStats) {
+    const options = buildGlobOptions({
+        cwd: root,
+        pattern,
+        excludePatterns,
+        includeHidden: normalized.includeHidden,
+        baseNameMatch: normalized.baseNameMatch,
+        caseSensitiveMatch: true,
+        followSymbolicLinks: false,
+        onlyFiles: true,
+        stats: needsStats,
+        ...(normalized.maxDepth !== undefined
+            ? { maxDepth: normalized.maxDepth }
+            : {}),
+    });
+    return globEntries(options);
+}
+function buildCollectResult(state) {
+    const outcome = {
+        results: state.results,
+        filesScanned: state.filesScanned,
+        truncated: state.truncated,
+        skippedInaccessible: state.skippedInaccessible,
+    };
+    if (state.stoppedReason !== undefined) {
+        outcome.stoppedReason = state.stoppedReason;
+    }
+    return outcome;
+}
+function handleEntry(entry, entryType, needsStats, normalized, state) {
+    state.results.push(buildSearchFilesResult(entry, entryType, needsStats));
+    if (state.results.length >= normalized.maxResults) {
+        state.truncated = true;
+        state.stoppedReason = 'maxResults';
+    }
+}
+async function collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, accessDeps, onProgress) {
+    for await (const entry of stream) {
+        if (shouldStopCollecting(state, normalized, signal))
+            break;
+        state.filesScanned++;
+        reportPeriodicProgress(onProgress, state.filesScanned, {
+            total: normalized.maxFilesScanned,
+            throttleModulo: 25,
+        });
+        if (isEntryIgnoredByGitignore(gitignoreMatcher, root, entry.path, entry.relativePath)) {
+            continue;
+        }
+        const entryType = resolveEntryType(entry.dirent);
+        if (!shouldIncludeEntry(entryType, normalized)) {
+            continue;
+        }
+        const isAccessible = await isEntryAccessibleByType(entry.path, entryType, rootDirectories, signal, accessDeps);
+        if (!isAccessible) {
+            state.skippedInaccessible++;
+            continue;
+        }
+        handleEntry(entry, entryType, needsStats, normalized, state);
+        if (state.truncated)
+            break;
+    }
+    reportPeriodicProgress(onProgress, state.filesScanned, {
+        total: normalized.maxFilesScanned,
+        throttleModulo: 25,
+        force: true,
+    });
+}
+function isEntryIgnoredByGitignore(matcher, root, entryPath, relativePath) {
+    if (!matcher)
+        return false;
+    return isIgnoredByGitignore(matcher, root, entryPath, relativePath ? { relativePath } : {});
+}
+async function collectSearchResults(root, pattern, excludePatterns, normalized, signal, onProgress) {
+    const needsStats = needsStatsForSort(normalized.sortBy);
+    const stream = buildSearchStream(root, pattern, excludePatterns, normalized, needsStats);
+    const state = createCollectState();
+    const rootDirectories = [root];
+    const accessDeps = {
+        normalizePath,
+        isPathWithinDirectories,
+        isSensitivePath,
+        validateSymlinkPath: validateExistingPathDetailed,
+    };
+    const gitignoreMatcher = normalized.respectGitignore
+        ? await loadRootGitignore(root, signal)
+        : null;
+    await collectFromStream(stream, root, rootDirectories, gitignoreMatcher, normalized, needsStats, state, signal, accessDeps, onProgress);
+    return buildCollectResult(state);
+}
+function buildSearchSummary(results, filesScanned, truncated, stoppedReason, skippedInaccessible) {
+    const summary = {
+        matched: results.length,
+        truncated,
+        skippedInaccessible,
+        filesScanned,
+    };
+    return withOptionalStoppedReason(summary, stoppedReason);
+}
+function compareNameThenPath(a, b) {
+    const nameCompare = compareStringValues(a.name, b.name);
+    if (nameCompare !== 0)
+        return nameCompare;
+    return compareStringValues(a.path, b.path);
+}
+function comparePathThenName(a, b) {
+    const pathCompare = compareStringValues(a.path, b.path);
+    if (pathCompare !== 0)
+        return pathCompare;
+    return compareStringValues(a.name, b.name);
+}
+const SORT_COMPARATORS = {
+    size: (a, b) => compareOptionalNumberDesc(a.size, b.size, () => compareNameThenPath(a, b)),
+    modified: (a, b) => compareOptionalNumberDesc(a.modified?.getTime(), b.modified?.getTime(), () => compareNameThenPath(a, b)),
+    path: (a, b) => comparePathThenName(a, b),
+    name: (a, b) => compareNameThenPath(a, b),
+};
+export function sortSearchResults(results, sortBy) {
+    if (sortBy === 'name') {
+        stableSortByDerivedString(results, (item) => path.basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
+        return;
+    }
+    const comparator = SORT_COMPARATORS[sortBy];
+    results.sort(comparator);
+}
+async function runSearchFiles(root, pattern, excludePatterns, normalized, signal, onProgress) {
+    const { results, filesScanned, truncated, stoppedReason, skippedInaccessible, } = await collectSearchResults(root, pattern, excludePatterns, normalized, signal, onProgress);
+    sortSearchResults(results, normalized.sortBy);
+    return {
+        results,
+        summary: buildSearchSummary(results, filesScanned, truncated, stoppedReason, skippedInaccessible),
+    };
+}
+export async function searchFiles(basePath, pattern, excludePatterns = [], options = {}) {
+    const normalized = normalizeSearchFilesOptions(options);
+    return withTimedAbortSignal(options.signal, normalized.timeoutMs, async (signal) => {
+        const root = await validateExistingDirectory(basePath, signal);
+        const { results, summary } = await runSearchFiles(root, pattern, excludePatterns, normalized, signal, options.onProgress);
+        return {
+            basePath: root,
+            pattern,
+            results,
+            summary,
+        };
+    });
+}
+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';
+    const lit = options.isLiteral ? '1' : '0';
+    return `${pattern}|${cs}|${ww}|${lit}`;
+}
+function getCachedMatcher(pattern, options) {
+    const key = getMatcherCacheKey(pattern, options);
+    const cached = matcherCache.get(key);
+    if (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);
+}
+function evictOldestMatcherIfNeeded() {
+    if (matcherCache.size <= MAX_MATCHER_CACHE_SIZE)
+        return;
+    const firstKey = matcherCache.keys().next().value;
+    if (firstKey !== undefined) {
+        matcherCache.delete(firstKey);
+    }
+}
+const cancelledRequests = new Set();
+const activeRequests = new Set();
+let shuttingDown = false;
+function maybeFinishShutdown() {
+    if (!shuttingDown)
+        return;
+    if (activeRequests.size > 0)
+        return;
+    parentPort?.close();
+}
+function consumeCancelled(id) {
+    if (!cancelledRequests.has(id)) {
+        return false;
+    }
+    cancelledRequests.delete(id);
+    return true;
+}
+function markCancelledIfActive(id) {
+    if (activeRequests.has(id)) {
+        cancelledRequests.add(id);
+    }
+}
+function buildScanResponse(id, result) {
+    return {
+        type: 'result',
+        id,
+        result,
+    };
+}
+function buildErrorResponse(id, error) {
+    return {
+        type: 'error',
+        id,
+        error: formatUnknownErrorMessage(error),
+    };
+}
+async function handleScanRequest(request) {
+    const { id, resolvedPath, requestedPath, pattern, matcherOptions, scanOptions, maxMatches, } = request;
+    if (consumeCancelled(id))
+        return;
+    activeRequests.add(id);
+    const endMeasure = startPerfMeasure('searchWorker.scan', {
+        maxMatches,
+    });
+    let ok = false;
+    try {
+        const matcher = getCachedMatcher(pattern, matcherOptions);
+        const isCancelled = () => cancelledRequests.has(id);
+        const result = await scanFileInWorker(resolvedPath, requestedPath, matcher, scanOptions, maxMatches, isCancelled, isProbablyBinary);
+        if (consumeCancelled(id))
+            return;
+        parentPort?.postMessage(buildScanResponse(id, result));
+        ok = true;
+    }
+    catch (err) {
+        if (consumeCancelled(id))
+            return;
+        parentPort?.postMessage(buildErrorResponse(id, err));
+    }
+    finally {
+        activeRequests.delete(id);
+        cancelledRequests.delete(id);
+        endMeasure?.(ok);
+        maybeFinishShutdown();
+    }
+}
+function handleMessage(message) {
+    switch (message.type) {
+        case 'scan':
+            if (shuttingDown)
+                return;
+            void handleScanRequest(message);
+            break;
+        case 'cancel':
+            markCancelledIfActive(message.id);
+            break;
+        case 'shutdown':
+            shuttingDown = true;
+            for (const id of activeRequests) {
+                markCancelledIfActive(id);
+            }
+            maybeFinishShutdown();
+            break;
+    }
+}
+if (parentPort) {
+    parentPort.on('message', handleMessage);
+    const data = workerData;
+    if (data?.debug) {
+        console.error(`[SearchWorker] Started with threadId=${String(threadId)}`);
+    }
+}

package/dist/lib/file-operations/{glob-engine.d.ts → traversal.d.ts}

@@ -1,5 +1,5 @@
 import type { Stats } from 'node:fs';
-import type { DirentLike } from './common.js';
+import type { DirentLike } from './core.js';
 interface GlobEntry {
     path: string;
     relativePath?: string;
@@ -20,4 +20,21 @@ export interface GlobEntriesOptions {
     suppressErrors?: boolean;
 }
 export declare function globEntries(options: GlobEntriesOptions): AsyncGenerator<GlobEntry>;
+export interface GlobConfig {
+    cwd: string;
+    pattern: string;
+    excludePatterns?: readonly string[];
+    includeHidden?: boolean;
+    baseNameMatch?: boolean;
+    caseSensitiveMatch?: boolean;
+    followSymbolicLinks?: boolean;
+    onlyFiles?: boolean;
+    stats?: boolean;
+    maxDepth?: number;
+    suppressErrors?: boolean;
+}
+/**
+ * Builds standard options for globEntries to ensure consistency across search tools.
+ */
+export declare function buildGlobOptions(config: GlobConfig): Parameters<typeof globEntries>[0];
 export {};

package/dist/lib/file-operations/{glob-engine.js → traversal.js}

@@ -2,8 +2,8 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { glob as fsGlob } from 'node:fs/promises';
 import { getToolContextSnapshot, publishOpsTraceEnd, publishOpsTraceError, publishOpsTraceStart, shouldPublishOpsTrace, startPerfMeasure, } from '../observability.js';
-import { toPosixPath } from '../path-format.js';
-import { isRecord } from '../type-guards.js';
+import { toPosixPath } from '../paths.js';
+import { isRecord } from '../utils.js';
 const GLOB_MAGIC_RE = /[*?[\]{}!]/u;
 const DEFAULT_MAX_HIDDEN_DEPTH = 10;
 const GLOB_BATCH_CONCURRENCY = 64;
@@ -344,3 +344,26 @@ export async function* globEntries(options) {
         endMeasure?.(ok);
     }
 }
+/**
+ * Builds standard options for globEntries to ensure consistency across search tools.
+ */
+export function buildGlobOptions(config) {
+    const options = {
+        cwd: config.cwd,
+        pattern: config.pattern,
+        excludePatterns: config.excludePatterns ?? [],
+        includeHidden: config.includeHidden ?? false,
+        baseNameMatch: config.baseNameMatch ?? false,
+        caseSensitiveMatch: config.caseSensitiveMatch ?? true,
+        followSymbolicLinks: config.followSymbolicLinks ?? false,
+        onlyFiles: config.onlyFiles ?? true,
+        stats: config.stats ?? false,
+    };
+    if (config.suppressErrors) {
+        options.suppressErrors = config.suppressErrors;
+    }
+    if (config.maxDepth !== undefined) {
+        options.maxDepth = config.maxDepth;
+    }
+    return options;
+}

package/dist/lib/fs-helpers.js

@@ -6,8 +6,7 @@ import { Writable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 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 } from './path-policy.js';
-import { validateExistingPath } from './path-validation.js';
+import { assertAllowedFileAccess, validateExistingPath } from './paths.js';
 function createAbortError(message = 'Operation aborted') {
     return new DOMException(message, 'AbortError');
 }

package/dist/lib/observability.js

@@ -3,7 +3,7 @@ import { hash } from 'node:crypto';
 import { channel, tracingChannel } from 'node:diagnostics_channel';
 import { monitorEventLoopDelay, performance, PerformanceObserver, } from 'node:perf_hooks';
 import { parseTrueEnvFlag } from './constants.js';
-import { isRecord } from './type-guards.js';
+import { isRecord } from './utils.js';
 // --- Configuration ---
 const ENV = process.env;
 let _cachedConfig;

package/dist/lib/{path-validation.d.ts → paths.d.ts}

@@ -1,5 +1,8 @@
 import type { Root } from '@modelcontextprotocol/sdk/types.js';
 import { McpError } from './errors.js';
+export declare function toPosixPath(value: string): string;
+export declare function isSensitivePath(requestedPath: string, resolvedPath?: string): boolean;
+export declare function assertAllowedFileAccess(requestedPath: string, resolvedPath?: string): void;
 /**
  * Normalizes any path-like input to an absolute path suitable for comparisons.
  * - Expands "~" home directory shorthand.