@j0hanz/filesystem-mcp 1.7.3 → 1.9.0

package/dist/lib/path-policy.js

@@ -1,100 +0,0 @@
-import * as path from 'node:path';
-import { platform } from 'node:os';
-import { SENSITIVE_FILE_ALLOWLIST, SENSITIVE_FILE_DENYLIST, } from './constants.js';
-import { ErrorCode, McpError } from './errors.js';
-import { toPosixPath } from './path-format.js';
-const IS_WINDOWS = platform() === 'win32';
-const WINDOWS_ABSOLUTE_RE = /^[a-z]:\//iu;
-function normalizePathForMatch(input) {
-    return toPosixPath(path.normalize(input));
-}
-function normalizeForMatch(input) {
-    const normalized = normalizePathForMatch(input);
-    return IS_WINDOWS ? normalized.toLowerCase() : normalized;
-}
-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 (path.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(path.posix.basename(normalizedRequested), normalizedResolved ? path.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;
-    throw new McpError(ErrorCode.E_ACCESS_DENIED, `Access denied: sensitive file blocked by policy (${requestedPath}). ` +
-        'Set FS_CONTEXT_ALLOW_SENSITIVE=1 or use FS_CONTEXT_ALLOWLIST to override.', requestedPath);
-}

package/dist/lib/type-guards.d.ts

@@ -1 +0,0 @@
-export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/lib/type-guards.js

@@ -1,3 +0,0 @@
-export function isRecord(value) {
-    return value !== null && typeof value === 'object';
-}

package/dist/server/capabilities.d.ts

@@ -1,10 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-interface CapabilityOptions {
-    enablePromptListChanged?: boolean;
-    enableTaskToolRequests?: boolean;
-}
-type ServerCapabilities = NonNullable<ConstructorParameters<typeof McpServer>[1]>['capabilities'];
-type NonOptionalServerCapabilities = NonNullable<ServerCapabilities>;
-export declare function buildServerCapabilities(options?: CapabilityOptions): NonOptionalServerCapabilities;
-export declare function supportsTaskToolRequests(): boolean;
-export {};

package/dist/server/capabilities.js

@@ -1,48 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-let cachedTaskToolSupport;
-function detectTaskToolSupport() {
-    if (cachedTaskToolSupport !== undefined) {
-        return cachedTaskToolSupport;
-    }
-    try {
-        // Instantiate a minimal, unconnected probe server to duck-type check for
-        // task tool support. The probe has no transport or active connections, so
-        // close() only releases in-memory state; fire-and-forget is safe here.
-        const probe = new McpServer({
-            name: 'filesystem-mcp-capability-probe',
-            version: '0.0.0',
-        }, { capabilities: { tools: {} } });
-        cachedTaskToolSupport =
-            typeof probe.experimental.tasks.registerToolTask === 'function';
-        probe.close().catch(() => { });
-    }
-    catch {
-        cachedTaskToolSupport = false;
-    }
-    return cachedTaskToolSupport;
-}
-export function buildServerCapabilities(options = {}) {
-    const capabilities = {
-        logging: {},
-        resources: {},
-        tools: {},
-        prompts: options.enablePromptListChanged ? { listChanged: true } : {},
-        completions: {},
-    };
-    if (options.enableTaskToolRequests) {
-        // NOTE: enabling task tool requests requires the caller to configure
-        // an InMemoryTaskStore and InMemoryTaskMessageQueue on the McpServer.
-        // InMemoryTaskStore accumulates completed task records with no TTL eviction —
-        // suitable for short-lived stdio sessions. Long-running HTTP servers should
-        // replace it with a TTL-evicting store to avoid unbounded memory growth.
-        capabilities.tasks = {
-            list: {},
-            cancel: {},
-            requests: { tools: { call: {} } },
-        };
-    }
-    return capabilities;
-}
-export function supportsTaskToolRequests() {
-    return detectTaskToolSupport();
-}

package/dist/server/logging.d.ts

@@ -1,7 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
-export interface LoggingState {
-    minimumLevel: LoggingLevel;
-}
-export declare function createLoggingState(minimumLevel?: LoggingLevel): LoggingState;
-export declare function logToMcp(server: McpServer | undefined, level: LoggingLevel, data: string, minLevel?: LoggingLevel): void;

package/dist/server/logging.js

@@ -1,41 +0,0 @@
-import { formatUnknownErrorMessage } from '../lib/errors.js';
-import { isRecord } from '../lib/type-guards.js';
-const MCP_LOGGER_NAME = 'filesystem-mcp';
-const LOG_LEVEL_ORDER = {
-    debug: 0,
-    info: 1,
-    notice: 2,
-    warning: 3,
-    error: 4,
-    critical: 5,
-    alert: 6,
-    emergency: 7,
-};
-export function createLoggingState(minimumLevel = 'debug') {
-    return { minimumLevel };
-}
-function canSendMcpLogs(server) {
-    const capabilities = server.server.getClientCapabilities();
-    if (!isRecord(capabilities))
-        return false;
-    if (!('logging' in capabilities))
-        return false;
-    return !!capabilities['logging'];
-}
-export function logToMcp(server, level, data, minLevel = 'debug') {
-    if (LOG_LEVEL_ORDER[level] < LOG_LEVEL_ORDER[minLevel]) {
-        return;
-    }
-    if (!server || !canSendMcpLogs(server)) {
-        console.error(data);
-        return;
-    }
-    const params = {
-        level,
-        logger: MCP_LOGGER_NAME,
-        data,
-    };
-    void server.sendLoggingMessage(params).catch((error) => {
-        console.error(`Failed to send MCP log: ${level} | ${data}`, formatUnknownErrorMessage(error));
-    });
-}

package/dist/server/types.d.ts

@@ -1,4 +0,0 @@
-export interface ServerOptions {
-    allowCwd?: boolean;
-    cliAllowedDirs?: string[];
-}

package/dist/server/types.js

@@ -1 +0,0 @@
-export {};