@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/lib/paths.js

@@ -1,634 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { realpath, stat } from 'node:fs/promises';
-import { homedir, platform } from 'node:os';
-import { dirname, isAbsolute, join, normalize, parse, posix, relative, resolve, sep, win32, } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { assertNotAborted, withAbort } from './abort.js';
-import { SENSITIVE_FILE_ALLOWLIST, SENSITIVE_FILE_DENYLIST, } from './constants.js';
-import { ErrorCode, isAbortError, isNodeError, McpError } from './errors.js';
-import { Logger } from './logger.js';
-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;
-}
-const IS_WINDOWS = platform() === 'win32';
-const WINDOWS_ABSOLUTE_RE = /^[a-z]:\//iu;
-const HOME_PREFIX_LENGTH = 2;
-const CHAR_CODE_SPACE = 32;
-const CHAR_CODE_DOT = 46;
-function normalizePathForMatch(input) {
-    return toPosixPath(normalize(input));
-}
-function normalizeForMatch(input) {
-    const normalized = normalizePathForMatch(input);
-    // Always lowercase for case-insensitive denylist matching on all platforms.
-    // Prevents bypassing `.env` block with `.ENV` on case-sensitive filesystems.
-    return normalized.toLowerCase();
-}
-function compilePatternGlobs(normalizedPattern) {
-    const globs = new Set([normalizedPattern]);
-    const isWindowsAbsolute = WINDOWS_ABSOLUTE_RE.test(normalizedPattern);
-    if (!normalizedPattern.startsWith('**/') && !isWindowsAbsolute) {
-        const withoutRoot = normalizedPattern.replace(/^\/+/u, '');
-        if (withoutRoot.length > 0) {
-            globs.add(`**/${withoutRoot}`);
-        }
-    }
-    return [...globs];
-}
-function compilePatterns(patterns) {
-    const unique = new Set();
-    for (const pattern of patterns) {
-        const trimmed = pattern.trim();
-        if (trimmed.length > 0) {
-            unique.add(trimmed);
-        }
-    }
-    const compiled = [];
-    for (const pattern of unique) {
-        const normalized = normalizeForMatch(pattern);
-        const matchesPath = normalized.includes('/');
-        compiled.push({
-            globs: matchesPath ? compilePatternGlobs(normalized) : [normalized],
-            matchesPath,
-        });
-    }
-    return compiled;
-}
-function toPatternSet(patterns) {
-    const pathGlobs = new Set();
-    const nameGlobs = new Set();
-    for (const pattern of patterns) {
-        const target = pattern.matchesPath ? pathGlobs : nameGlobs;
-        for (const glob of pattern.globs) {
-            target.add(glob);
-        }
-    }
-    return {
-        pathGlobs: [...pathGlobs],
-        nameGlobs: [...nameGlobs],
-    };
-}
-const DENY_PATTERNS = toPatternSet(compilePatterns(SENSITIVE_FILE_DENYLIST));
-const ALLOW_PATTERNS = toPatternSet(compilePatterns(SENSITIVE_FILE_ALLOWLIST));
-function uniquePair(primary, secondary) {
-    if (!secondary || secondary === primary)
-        return [primary];
-    return [primary, secondary];
-}
-function matchesAnyGlobs(globs, candidates) {
-    if (globs.length === 0 || candidates.length === 0)
-        return false;
-    for (const candidate of candidates) {
-        for (const glob of globs) {
-            if (posix.matchesGlob(candidate, glob))
-                return true;
-        }
-    }
-    return false;
-}
-export function isSensitivePath(requestedPath, resolvedPath) {
-    if (DENY_PATTERNS.pathGlobs.length === 0 &&
-        DENY_PATTERNS.nameGlobs.length === 0) {
-        return false;
-    }
-    const normalizedRequested = normalizeForMatch(requestedPath);
-    const normalizedResolved = resolvedPath
-        ? normalizeForMatch(resolvedPath)
-        : undefined;
-    const pathCandidates = uniquePair(normalizedRequested, normalizedResolved);
-    const nameCandidates = uniquePair(posix.basename(normalizedRequested), normalizedResolved ? posix.basename(normalizedResolved) : undefined);
-    if (matchesAnyGlobs(ALLOW_PATTERNS.pathGlobs, pathCandidates) ||
-        matchesAnyGlobs(ALLOW_PATTERNS.nameGlobs, nameCandidates)) {
-        return false;
-    }
-    return (matchesAnyGlobs(DENY_PATTERNS.pathGlobs, pathCandidates) ||
-        matchesAnyGlobs(DENY_PATTERNS.nameGlobs, nameCandidates));
-}
-export function assertAllowedFileAccess(requestedPath, resolvedPath) {
-    if (!isSensitivePath(requestedPath, resolvedPath))
-        return;
-    Logger.warn(`Access denied: sensitive file blocked by policy (${requestedPath})`);
-    throw new McpError(ErrorCode.ACCESS_DENIED, 'Sensitive file blocked. Set FS_CONTEXT_ALLOW_SENSITIVE=1 to override.', requestedPath);
-}
-const HOMEDIR = homedir();
-const PATH_SEPARATOR = sep;
-const DRIVE_LETTER_REGEX = /^[A-Za-z]:/;
-const WINDOWS_DRIVE_REL_REGEX = /^[A-Za-z]:$/u;
-const LEADING_SEPARATORS_RE = /^[/\\]+/;
-const RESERVED_DEVICE_NAMES = new Set([
-    'CON',
-    'PRN',
-    'AUX',
-    'NUL',
-    'COM1',
-    'COM2',
-    'COM3',
-    'COM4',
-    'COM5',
-    'COM6',
-    'COM7',
-    'COM8',
-    'COM9',
-    'LPT1',
-    'LPT2',
-    'LPT3',
-    'LPT4',
-    'LPT5',
-    'LPT6',
-    'LPT7',
-    'LPT8',
-    'LPT9',
-]);
-const allowedDirectoriesContext = new AsyncLocalStorage({
-    name: 'filesystem-mcp:allowed-directories',
-});
-function dedupePreserveOrder(items) {
-    return [...new Set(items)];
-}
-function cloneAllowedDirectoriesState(state) {
-    return {
-        primary: [...state.primary],
-        expanded: [...state.expanded],
-    };
-}
-function expandHome(filepath) {
-    if (filepath === '~')
-        return HOMEDIR;
-    // Accept both "~/" and "~\\" for cross-platform UX.
-    if (filepath.startsWith('~/') || filepath.startsWith('~\\')) {
-        // Avoid `join(HOMEDIR, "/foo")` resetting to the filesystem root.
-        const rest = filepath
-            .slice(HOME_PREFIX_LENGTH)
-            .replace(LEADING_SEPARATORS_RE, '');
-        return rest.length === 0 ? HOMEDIR : join(HOMEDIR, rest);
-    }
-    return filepath;
-}
-/**
- * Normalizes any path-like input to an absolute path suitable for comparisons.
- * - Expands "~" home directory shorthand.
- * - Resolves against process CWD if relative.
- * - Lowercases Windows drive letter for stable comparisons.
- */
-export function normalizePath(p) {
-    const resolved = resolve(expandHome(p));
-    if (IS_WINDOWS && DRIVE_LETTER_REGEX.test(resolved)) {
-        return resolved.charAt(0).toLowerCase() + resolved.slice(1);
-    }
-    return resolved;
-}
-function normalizeCaseForComparison(value) {
-    return IS_WINDOWS ? value.toLowerCase() : value;
-}
-function normalizeForComparison(value) {
-    return normalizeCaseForComparison(value);
-}
-function rethrowIfAborted(error) {
-    if (isAbortError(error))
-        throw error;
-}
-function isSamePath(left, right) {
-    if (left === right)
-        return true;
-    const leftResolved = normalizeCaseForComparison(resolve(left));
-    const rightResolved = normalizeCaseForComparison(resolve(right));
-    return leftResolved === rightResolved;
-}
-function stripTrailingSeparator(normalized) {
-    return normalized.length > 1 && normalized.endsWith(PATH_SEPARATOR)
-        ? normalized.slice(0, -1)
-        : normalized;
-}
-function isFileSystemRootPath(normalized, root) {
-    return isSamePath(normalized, root);
-}
-function normalizeAllowedDirectory(dir) {
-    const trimmed = dir.trim();
-    if (trimmed.length === 0)
-        return '';
-    const normalized = normalizePath(trimmed);
-    const { root } = parse(normalized);
-    // Keep filesystem roots as-is ("/", "c:\\", "\\\\server\\share\\").
-    if (isFileSystemRootPath(normalized, root)) {
-        return root;
-    }
-    return stripTrailingSeparator(normalized);
-}
-function normalizeAllowedDirectories(dirs) {
-    const normalized = [];
-    for (const dir of dirs) {
-        const entry = normalizeAllowedDirectory(dir);
-        if (entry.length > 0) {
-            normalized.push(entry);
-        }
-    }
-    // Preserve first-seen order while deduping.
-    return dedupePreserveOrder(normalized);
-}
-// Process-global singleton state for allowed directory roots.
-//
-// These are set once at startup (via setAllowedDirectoriesResolved) and
-// mutated only through setAllowedDirectoriesState. In stdio mode there is a
-// single MCP session per process, so this is safe. In HTTP mode all HTTP
-// sessions within the same process share one policy — multi-tenant isolation
-// (different roots per session) requires separate server processes.
-let defaultAllowedDirectoriesState = {
-    primary: [],
-    expanded: [],
-};
-function setAllowedDirectoriesState(primary, expanded) {
-    defaultAllowedDirectoriesState = {
-        primary: dedupePreserveOrder(primary),
-        expanded: dedupePreserveOrder(expanded),
-    };
-}
-function getActiveAllowedDirectoriesState() {
-    return allowedDirectoriesContext.getStore() ?? defaultAllowedDirectoriesState;
-}
-export function withAllowedDirectoriesState(state, run) {
-    return allowedDirectoriesContext.run(cloneAllowedDirectoriesState(state), run);
-}
-export function setAllowedDirectoriesStateResolved(state) {
-    setAllowedDirectoriesState(state.primary, state.expanded);
-}
-export function getAllowedDirectories() {
-    return [...getActiveAllowedDirectoriesState().expanded];
-}
-export function isAllowedDirectoryRoot(normalizedPath) {
-    for (const dir of getActiveAllowedDirectoriesState().expanded) {
-        if (isSamePath(normalizedPath, dir))
-            return true;
-    }
-    return false;
-}
-function getAllowedDirectoriesForRelativeResolution() {
-    const state = getActiveAllowedDirectoriesState();
-    return state.primary.length > 0 ? state.primary : state.expanded;
-}
-function isPathInsideDirectory(normalizedDirectory, normalizedCandidate) {
-    const root = normalizeForComparison(normalizedDirectory);
-    const candidate = normalizeForComparison(normalizedCandidate);
-    if (root === candidate)
-        return true;
-    const rel = relative(root, candidate);
-    if (rel.length === 0)
-        return true;
-    if (rel === '..')
-        return false;
-    return !rel.startsWith('..\\') && !rel.startsWith('../') && !isAbsolute(rel);
-}
-export function isPathWithinDirectories(normalizedPath, allowedDirs) {
-    for (const allowedDir of allowedDirs) {
-        if (isPathInsideDirectory(allowedDir, normalizedPath))
-            return true;
-    }
-    return false;
-}
-async function resolveRealPath(normalized, signal) {
-    try {
-        assertNotAborted(signal);
-        const realPath = await withAbort(realpath(normalized), signal);
-        return normalizeAllowedDirectory(realPath);
-    }
-    catch (error) {
-        rethrowIfAborted(error);
-        return null;
-    }
-}
-async function expandAllowedDirectories(primaryDirs, signal) {
-    const realPaths = await Promise.all(primaryDirs.map((dir) => resolveRealPath(dir, signal)));
-    const expanded = [];
-    for (let i = 0; i < primaryDirs.length; i++) {
-        const primary = primaryDirs[i];
-        if (!primary)
-            continue;
-        expanded.push(primary);
-        const real = realPaths[i];
-        if (real && !isSamePath(real, primary)) {
-            expanded.push(real);
-        }
-    }
-    return dedupePreserveOrder(expanded);
-}
-export async function resolveAllowedDirectoriesState(dirs, signal) {
-    const primary = normalizeAllowedDirectories(dirs);
-    const expanded = await expandAllowedDirectories(primary, signal);
-    return { primary, expanded };
-}
-export async function setAllowedDirectoriesResolved(dirs, signal) {
-    const state = await resolveAllowedDirectoriesState(dirs, signal);
-    setAllowedDirectoriesStateResolved(state);
-}
-function ensureNonEmptyPath(requestedPath) {
-    if (!requestedPath || requestedPath.trim().length === 0) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Path cannot be empty or whitespace', requestedPath);
-    }
-}
-function ensureNoNullBytes(requestedPath) {
-    if (requestedPath.includes('\0')) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Path contains null bytes', requestedPath);
-    }
-}
-function getReservedDeviceName(segment) {
-    // Trim trailing dots/spaces (Windows ignores these in path segments).
-    let end = segment.length;
-    while (end > 0) {
-        const c = segment.charCodeAt(end - 1);
-        if (c === CHAR_CODE_SPACE || c === CHAR_CODE_DOT)
-            end--; // space or dot
-        else
-            break;
-    }
-    const trimmed = segment.slice(0, end);
-    // Remove alternate data stream suffix (e.g. "file.txt:stream").
-    const streamIdx = trimmed.indexOf(':');
-    const withoutStream = streamIdx !== -1 ? trimmed.slice(0, streamIdx) : trimmed;
-    // Remove extension (e.g. "CON.txt" => "CON").
-    const dotIdx = withoutStream.indexOf('.');
-    const baseName = (dotIdx !== -1 ? withoutStream.slice(0, dotIdx) : withoutStream).toUpperCase();
-    return RESERVED_DEVICE_NAMES.has(baseName) ? baseName : undefined;
-}
-export function getReservedDeviceNameForPath(requestedPath) {
-    if (!IS_WINDOWS)
-        return undefined;
-    const segments = requestedPath.split(/[\\/]/);
-    for (const segment of segments) {
-        const reserved = getReservedDeviceName(segment);
-        if (reserved)
-            return reserved;
-    }
-    return undefined;
-}
-function ensureNoReservedWindowsNames(requestedPath) {
-    if (!IS_WINDOWS)
-        return;
-    const reserved = getReservedDeviceNameForPath(requestedPath);
-    if (!reserved)
-        return;
-    throw new McpError(ErrorCode.INVALID_INPUT, `Windows reserved device name not allowed: ${reserved}`, requestedPath);
-}
-export function isWindowsDriveRelativePath(requestedPath) {
-    if (!IS_WINDOWS)
-        return false;
-    const parsed = win32.parse(requestedPath);
-    if (!WINDOWS_DRIVE_REL_REGEX.test(parsed.root))
-        return false;
-    return !win32.isAbsolute(requestedPath);
-}
-function ensureNoWindowsDriveRelativePath(requestedPath) {
-    if (!isWindowsDriveRelativePath(requestedPath))
-        return;
-    throw new McpError(ErrorCode.INVALID_INPUT, 'Drive-relative path not allowed. Use C:\\path instead of C:path.', requestedPath);
-}
-function resolveRequestedPath(requestedPath) {
-    const expanded = expandHome(requestedPath);
-    if (!isAbsolute(expanded)) {
-        const roots = getAllowedDirectoriesForRelativeResolution();
-        if (roots.length > 1) {
-            throw new McpError(ErrorCode.INVALID_INPUT, 'Ambiguous relative path with multiple roots. Use an absolute path.', requestedPath);
-        }
-        const baseDir = roots[0];
-        if (baseDir) {
-            return normalizePath(resolve(baseDir, expanded));
-        }
-    }
-    return normalizePath(expanded);
-}
-function validateRequestedPath(requestedPath) {
-    ensureNonEmptyPath(requestedPath);
-    ensureNoNullBytes(requestedPath);
-    ensureNoReservedWindowsNames(requestedPath);
-    ensureNoWindowsDriveRelativePath(requestedPath);
-    return resolveRequestedPath(requestedPath);
-}
-const NODE_ERROR_MAP = {
-    ENOENT: {
-        code: ErrorCode.NOT_FOUND,
-        message: () => 'Path does not exist',
-    },
-    EACCES: {
-        code: ErrorCode.PERMISSION_DENIED,
-        message: () => 'Permission denied',
-    },
-    EPERM: {
-        code: ErrorCode.PERMISSION_DENIED,
-        message: () => 'Permission denied',
-    },
-    ELOOP: {
-        code: ErrorCode.SYMLINK_NOT_ALLOWED,
-        message: () => 'Too many symbolic links (circular reference)',
-    },
-    ENAMETOOLONG: {
-        code: ErrorCode.INVALID_INPUT,
-        message: () => 'Path name too long',
-    },
-};
-function buildAllowedDirectoriesHint() {
-    const dirs = getAllowedDirectories();
-    return dirs.length > 0
-        ? `Allowed: ${dirs.join(', ')}`
-        : 'No allowed directories configured.';
-}
-function toMcpError(requestedPath, error) {
-    const code = isNodeError(error) ? error.code : undefined;
-    const mapping = code ? NODE_ERROR_MAP[code] : undefined;
-    if (mapping) {
-        return new McpError(mapping.code, mapping.message(requestedPath), requestedPath, { originalCode: code }, error);
-    }
-    let originalMessage = '';
-    if (error instanceof Error) {
-        originalMessage = error.message;
-    }
-    else if (typeof error === 'string') {
-        originalMessage = error;
-    }
-    return new McpError(ErrorCode.NOT_FOUND, 'Path is not accessible', requestedPath, { originalCode: code, originalMessage }, error);
-}
-function toAccessDeniedWithHint(requestedPath, resolvedPath, normalizedResolved) {
-    const suggestion = buildAllowedDirectoriesHint();
-    return new McpError(ErrorCode.ACCESS_DENIED, `Outside allowed directories. ${suggestion}`, requestedPath, { resolvedPath, normalizedResolvedPath: normalizedResolved });
-}
-function ensureWithinAllowedDirectories(options) {
-    const { normalizedPath, requestedPath, allowedDirs, details } = options;
-    if (isPathWithinDirectories(normalizedPath, allowedDirs))
-        return;
-    if (allowedDirs.length === 0) {
-        Logger.warn('Access denied: no allowed directories configured');
-        throw new McpError(ErrorCode.ACCESS_DENIED, 'No allowed directories configured. Use --allow-cwd or configure roots.', requestedPath, details);
-    }
-    Logger.warn(`Access denied: path outside allowed directories (${requestedPath})`);
-    throw new McpError(ErrorCode.ACCESS_DENIED, 'Outside allowed directories', requestedPath, details);
-}
-async function resolveRealPathOrThrow(options) {
-    const { requestedPath, normalizedRequested, signal } = options;
-    try {
-        assertNotAborted(signal);
-        return await withAbort(realpath(normalizedRequested), signal);
-    }
-    catch (error) {
-        rethrowIfAborted(error);
-        throw toMcpError(requestedPath, error);
-    }
-}
-function preparePathAccess(requestedPath) {
-    const normalizedRequested = validateRequestedPath(requestedPath);
-    const allowedDirs = getAllowedDirectories();
-    ensureWithinAllowedDirectories({
-        normalizedPath: normalizedRequested,
-        requestedPath,
-        allowedDirs,
-        details: { normalizedPath: normalizedRequested },
-    });
-    return { allowedDirs, normalizedRequested };
-}
-function ensureResolvedPathAllowed(options) {
-    const { requestedPath, resolvedPath, normalizedResolved, allowedDirs } = options;
-    if (isPathWithinDirectories(normalizedResolved, allowedDirs))
-        return;
-    throw toAccessDeniedWithHint(requestedPath, resolvedPath, normalizedResolved);
-}
-async function statPathOrThrow(requestedPath, resolvedPath, signal) {
-    try {
-        assertNotAborted(signal);
-        return await withAbort(stat(resolvedPath), signal);
-    }
-    catch (error) {
-        rethrowIfAborted(error);
-        throw toMcpError(requestedPath, error);
-    }
-}
-async function resolveNearestExistingRealPathOrThrow(options) {
-    const { requestedPath, startPath, signal } = options;
-    let current = startPath;
-    for (;;) {
-        try {
-            assertNotAborted(signal);
-            return await withAbort(realpath(current), signal);
-        }
-        catch (error) {
-            rethrowIfAborted(error);
-            const code = isNodeError(error) ? error.code : undefined;
-            if (code !== 'ENOENT') {
-                throw toMcpError(requestedPath, error);
-            }
-            const parent = dirname(current);
-            if (parent === current) {
-                throw toMcpError(requestedPath, error);
-            }
-            current = parent;
-        }
-    }
-}
-async function validateExistingPathDetailsInternal(requestedPath, signal) {
-    const { allowedDirs, normalizedRequested } = preparePathAccess(requestedPath);
-    const realPath = await resolveRealPathOrThrow({
-        requestedPath,
-        normalizedRequested,
-        ...(signal ? { signal } : {}),
-    });
-    const normalizedReal = normalizePath(realPath);
-    ensureResolvedPathAllowed({
-        requestedPath,
-        resolvedPath: realPath,
-        normalizedResolved: normalizedReal,
-        allowedDirs,
-    });
-    return {
-        requestedPath: normalizedRequested,
-        resolvedPath: normalizedReal,
-        isSymlink: !isSamePath(normalizedRequested, normalizedReal),
-    };
-}
-export async function validateExistingPathDetailed(requestedPath, signal) {
-    return validateExistingPathDetailsInternal(requestedPath, signal);
-}
-export async function validateExistingPath(requestedPath, signal) {
-    const details = await validateExistingPathDetailsInternal(requestedPath, signal);
-    return details.resolvedPath;
-}
-export async function validateExistingDirectory(requestedPath, signal) {
-    const details = await validateExistingPathDetailsInternal(requestedPath, signal);
-    const stats = await statPathOrThrow(requestedPath, details.resolvedPath, signal);
-    if (!stats.isDirectory()) {
-        throw new McpError(ErrorCode.NOT_DIRECTORY, 'Not a directory', requestedPath);
-    }
-    return details.resolvedPath;
-}
-export async function validatePathForWrite(requestedPath, signal) {
-    const { allowedDirs, normalizedRequested } = preparePathAccess(requestedPath);
-    assertAllowedFileAccess(requestedPath, normalizedRequested);
-    const realPath = await resolveNearestExistingRealPathOrThrow({
-        requestedPath,
-        startPath: normalizedRequested,
-        ...(signal ? { signal } : {}),
-    });
-    const normalizedReal = normalizePath(realPath);
-    ensureResolvedPathAllowed({
-        requestedPath,
-        resolvedPath: realPath,
-        normalizedResolved: normalizedReal,
-        allowedDirs,
-    });
-    return normalizedRequested;
-}
-function isFileRoot(root) {
-    return root.uri.startsWith('file://');
-}
-async function maybeAddRealPath(normalizedPath, validDirs, signal) {
-    try {
-        assertNotAborted(signal);
-        const realPath = await withAbort(realpath(normalizedPath), signal);
-        const normalizedReal = normalizePath(realPath);
-        if (!isSamePath(normalizedReal, normalizedPath)) {
-            validDirs.push(normalizedReal);
-        }
-    }
-    catch (error) {
-        rethrowIfAborted(error);
-    }
-}
-async function resolveRootDirectory(root, signal) {
-    try {
-        const dirPath = fileURLToPath(root.uri);
-        const normalizedPath = normalizePath(dirPath);
-        assertNotAborted(signal);
-        const stats = await withAbort(stat(normalizedPath), signal);
-        if (!stats.isDirectory())
-            return null;
-        return normalizedPath;
-    }
-    catch (error) {
-        rethrowIfAborted(error);
-        return null;
-    }
-}
-export async function getValidRootDirectories(roots, signal) {
-    const fileRoots = roots.filter(isFileRoot);
-    if (fileRoots.length === 0)
-        return [];
-    // Phase 1: Resolve all roots in parallel (order-preserving via index).
-    const resolvedResults = await Promise.all(fileRoots.map((root) => resolveRootDirectory(root, signal)));
-    const validPaths = resolvedResults.filter((p) => p !== null);
-    if (validPaths.length === 0)
-        return [];
-    // Phase 2: Expand real paths for each valid directory in parallel.
-    const realExpansions = await Promise.all(validPaths.map(async (normalizedPath) => {
-        const extra = [];
-        await maybeAddRealPath(normalizedPath, extra, signal);
-        return extra[0] ?? null;
-    }));
-    // Build output preserving insertion order: [normalizedPath, realPath?] per root.
-    const validDirs = [];
-    validPaths.forEach((p, i) => {
-        validDirs.push(p);
-        const expanded = realExpansions[i];
-        if (expanded !== null && expanded !== undefined) {
-            validDirs.push(expanded);
-        }
-    });
-    return validDirs;
-}

package/dist/lib/resource-store.d.ts

@@ -1,28 +0,0 @@
-export interface TextResourceEntry {
-    uri: string;
-    name: string;
-    mimeType: string;
-    text: string;
-    hash: string;
-    size: number;
-    storedAt: string;
-    expiresAt: string;
-}
-export interface ResourceStore {
-    putText(params: {
-        name: string;
-        mimeType?: string;
-        text: string;
-    }): TextResourceEntry;
-    getText(uri: string): TextResourceEntry;
-    clear(): void;
-    keys(): string[];
-}
-interface ResourceStoreOptions {
-    maxEntries: number;
-    maxTotalBytes: number;
-    maxEntryBytes: number;
-    entryTtlMs: number;
-}
-export declare function createInMemoryResourceStore(options?: Partial<ResourceStoreOptions>): ResourceStore;
-export {};