@j0hanz/filesystem-mcp 1.8.0 → 1.9.0

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

@@ -1,10 +1,113 @@
 import * as fs from 'node:fs/promises';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { platform } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { SENSITIVE_FILE_ALLOWLIST, SENSITIVE_FILE_DENYLIST, } from './constants.js';
 import { ErrorCode, isAbortError, isNodeError, McpError } from './errors.js';
 import { assertNotAborted, withAbort } from './fs-helpers.js';
-const IS_WINDOWS = os.platform() === 'win32';
+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;
+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);
+}
 const HOMEDIR = os.homedir();
 const PATH_SEPARATOR = path.sep;
 const DRIVE_LETTER_REGEX = /^[A-Za-z]:/;
@@ -393,6 +496,7 @@ export async function validatePathForWrite(requestedPath, signal) {
         allowedDirs,
         details: { normalizedPath: normalizedRequested },
     });
+    assertAllowedFileAccess(requestedPath, normalizedRequested);
     let current = normalizedRequested;
     for (;;) {
         try {

package/dist/lib/utils.d.ts

@@ -0,0 +1,15 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function mergeOptions<T extends object>(defaults: T, overrides: Partial<T>): T;
+export declare function omitOptionKeys<T extends object, K extends keyof T>(input: T, keys: readonly K[]): Omit<T, K>;
+export declare function setIfDefined<T extends object, K extends keyof T>(target: T, key: K, value: T[K] | undefined): void;
+export interface ProgressPayload {
+    current: number;
+    total?: number;
+}
+export type ProgressCallback = ((progress: ProgressPayload) => void) | undefined;
+export interface PeriodicProgressOptions {
+    total?: number;
+    throttleModulo?: number;
+    force?: boolean;
+}
+export declare function reportPeriodicProgress(onProgress: ProgressCallback, current: number, options?: PeriodicProgressOptions): void;

package/dist/lib/utils.js

@@ -0,0 +1,33 @@
+// type-guards.ts
+export function isRecord(value) {
+    return value !== null && typeof value === 'object';
+}
+// option-utils.ts
+export function mergeOptions(defaults, overrides) {
+    return { ...defaults, ...overrides };
+}
+export function omitOptionKeys(input, keys) {
+    const output = { ...input };
+    for (const key of keys) {
+        Reflect.deleteProperty(output, key);
+    }
+    return output;
+}
+export function setIfDefined(target, key, value) {
+    if (value !== undefined) {
+        target[key] = value;
+    }
+}
+export function reportPeriodicProgress(onProgress, current, options = {}) {
+    if (!onProgress || current === 0)
+        return;
+    const throttleModulo = options.throttleModulo ?? 1;
+    const force = options.force ?? false;
+    if (!force && throttleModulo > 1 && current % throttleModulo !== 0) {
+        return;
+    }
+    onProgress({
+        current,
+        ...(options.total !== undefined ? { total: options.total } : {}),
+    });
+}

package/dist/resources/generated-instructions.js

@@ -2,7 +2,7 @@ import { buildToolCatalogDetailsOnly } from './tool-catalog.js';
 import { buildCoreContextPack, getSharedConstraints, getToolContracts, } from './tool-info.js';
 import { buildWorkflowGuide } from './workflows.js';
 const INSTRUCTIONS_HEADER = `<role>
-Filesystem agent for local paths only. Operate inside allowed roots. Discover before action. Never guess paths.
+Filesystem agent. Scope: allowed roots only. Discover paths before acting — never guess.
 </role>
 
 <tools_overview>
@@ -16,10 +16,10 @@ Filesystem agent for local paths only. Operate inside allowed roots. Discover be
 
 <resources>
 - \`internal://instructions\`: Full usage reference.
-- \`internal://tool-catalog\`: Tool routing and data-flow rules.
+- \`internal://tool-catalog\`: Tool routing and data flow.
 - \`internal://workflows\`: Standard execution sequences.
-- \`internal://tool-info/{name}\`: Per-tool nuances and gotchas (example: \`internal://tool-info/read\`).
-- \`filesystem-mcp://result/{id}\`: Cached large output. If \`resourceUri\` is returned, call \`resources/read\` immediately.
+- \`internal://tool-info/{name}\`: Per-tool nuances (e.g. \`internal://tool-info/read\`).
+- \`filesystem-mcp://result/{id}\`: Cached large output — call \`resources/read\` immediately when \`resourceUri\` is returned.
 - \`filesystem-mcp://metrics\`: Per-tool runtime metrics.
 </resources>
 
@@ -35,8 +35,8 @@ ${getSharedConstraints()
 </constraints>
 
 <error_handling>
-- \`E_ACCESS_DENIED\` => call \`roots\`, then use an allowed path.
-- \`E_NOT_FOUND\` => call \`ls\` or \`find\`, then verify spelling.
+- \`E_ACCESS_DENIED\` => call \`roots\`, use an allowed path.
+- \`E_NOT_FOUND\` => call \`ls\` or \`find\`, verify spelling.
 - \`E_TOO_LARGE\` => use \`head\`, line ranges, or \`read_many\`.
 - \`E_TIMEOUT\` => reduce scope or result limits.
 </error_handling>

package/dist/resources/tool-catalog.js

@@ -3,26 +3,26 @@ const CATALOG_GUIDE = `<tool_selection_guide>
 ## Cross-Tool Data Flow
 
 \`\`\`
-find (results[].path) -> grep.paths
-diff_files (patch text) -> apply_patch.patch
+find(results[].path) -> grep.paths
+diff_files(patch) -> apply_patch.patch
 \`\`\`
 
 ## Search Strategy
 
-- Use \`find\` for glob file discovery.
-- Use \`grep\` for text search.
-- Use \`search_and_replace\` only for replacement, never discovery.
+- \`find\`: glob file discovery.
+- \`grep\`: text content search.
+- \`search_and_replace\`: replacement only, not discovery.
 
 ## Write Strategy
 
-- Use \`edit\` for precise, first-occurrence replacements in existing files.
-- Use \`write\` to create files or overwrite full contents.
-- Use \`search_and_replace\` for bulk multi-file replacements.
+- \`edit\`: precise first-occurrence replacements.
+- \`write\`: create files or overwrite full contents.
+- \`search_and_replace\`: bulk multi-file replacements.
 
 ## Patch Management
 
 - Generate patches with \`diff_files\` first.
-- Run \`apply_patch\` with \`dryRun: true\` before writing.
+- Validate with \`apply_patch(dryRun:true)\` before writing.
 - \`apply_patch\` accepts unified diffs only.
 </tool_selection_guide>
 `;

package/dist/resources/tool-info.js

@@ -37,10 +37,10 @@ export function buildCoreContextPack() {
 }
 export function getSharedConstraints() {
     return [
-        'Use allowed roots only (provided by CLI negotiation).',
+        'Use allowed roots only (from CLI negotiation).',
         'Sensitive paths are denylisted by default.',
-        `Limits are enforced: max file size ${Math.floor(MAX_TEXT_FILE_SIZE / 1024 / 1024)}MB; search caps ${MAX_SEARCH_RESULTS} files and ${DEFAULT_SEARCH_CONTENT_RESULTS} lines.`,
-        'If a response includes `resourceUri`, call `resources/read` immediately; cached results expire on process restart.',
+        `Limits enforced: max file size ${Math.floor(MAX_TEXT_FILE_SIZE / 1024 / 1024)}MB; search caps ${MAX_SEARCH_RESULTS} files, ${DEFAULT_SEARCH_CONTENT_RESULTS} content matches.`,
+        'If response includes `resourceUri`, call `resources/read` immediately — cached results expire on restart.',
     ];
 }
 export function buildToolInfo(name) {

package/dist/resources/workflows.js

@@ -1,33 +1,20 @@
 export function buildWorkflowGuide() {
     return `<workflows>
-### A: EXPLORE
-Use when: you need directory layout or file content.
-1. \`roots\` (list allowed paths).
-2. \`ls\` (flat view) or \`tree\` (recursive view).
-3. \`stat\` or \`stat_many\` (type and size checks).
-4. \`read\` or \`read_many\` (read content).
+### A: EXPLORE — directory layout or file content
+1. \`roots\` → \`ls\` or \`tree\` → \`stat\`/\`stat_many\` → \`read\`/\`read_many\`.
    > **Strict:** Resolve paths first. Never guess.
 
-### B: SEARCH
-Use when: you need files by pattern or content.
-1. \`find\` (glob candidates).
-2. \`grep\` (content matches).
-3. \`read\` (verify matched context).
-   > **Strict:** Do content search with \`grep\`, not \`find\`.
+### B: SEARCH — files by pattern or content
+1. \`find\` (glob) → \`grep\` (content) → \`read\` (verify).
+   > **Strict:** Content search with \`grep\`, not \`find\`.
 
-### C: EDIT
-Use when: you need to modify files or layout.
-1. \`edit\` (targeted string replacement).
-2. \`search_and_replace\` (bulk replacements).
-3. \`mv\` or \`rm\` (layout changes).
-4. \`mkdir\` (directory creation).
+### C: EDIT — modify files or layout
+1. \`edit\` (targeted replacement) or \`search_and_replace\` (bulk).
+2. \`mv\`/\`rm\` (layout) or \`mkdir\` (create dirs).
    > **Strict:** Confirm destructive ops (\`write\`, \`mv\`, \`rm\`, bulk replace).
 
-### D: PATCH
-Use when: applying unified diffs from \`diff_files\`.
-1. \`diff_files\` (generate).
-2. \`apply_patch\` (dryRun: true).
-3. \`apply_patch\` (dryRun: false).
+### D: PATCH — apply unified diffs
+1. \`diff_files\` → \`apply_patch(dryRun:true)\` → \`apply_patch\`.
    > **Tip:** Feed \`diff_files\` output directly to \`apply_patch\`.
 </workflows>`;
 }

package/dist/schemas.js

@@ -16,8 +16,8 @@ function isSafeGlobPattern(value) {
     return true;
 }
 const MAX_PATH_LENGTH = 4096;
-const DESC_PATH_ROOT = 'Base directory (default: root). Absolute path required if multiple roots exist. Examples: "src", "src/components"';
-const DESC_PATH_REQUIRED = 'Absolute path to file or directory. Examples: "src/index.ts", "README.md"';
+const DESC_PATH_ROOT = 'Base directory (default: root). Absolute path required if multiple roots.';
+const DESC_PATH_REQUIRED = 'Absolute path to file or directory.';
 function defaultFalseBoolean(description) {
     return z.boolean().optional().default(false).describe(description);
 }
@@ -209,9 +209,9 @@ export const SearchContentInputSchema = z.strictObject({
         .string()
         .min(1, 'Pattern required')
         .max(1000, 'Max 1000 chars')
-        .describe('Literal text to search for by default; treated as RE2 regex when isRegex is true.'),
-    isRegex: defaultFalseBoolean('Treat pattern as a RE2 regular expression. RE2 does not support lookahead, lookbehind, or backreferences.'),
-    caseSensitive: defaultFalseBoolean('Case-sensitive matching (default: false — searches are case-insensitive).'),
+        .describe('Search text. RE2 regex when `isRegex=true`.'),
+    isRegex: defaultFalseBoolean('Treat pattern as RE2 regex (no lookahead/lookbehind/backrefs).'),
+    caseSensitive: defaultFalseBoolean('Case-sensitive matching. Default: case-insensitive.'),
     wholeWord: defaultFalseBoolean('Match whole words only'),
     contextLines: z
         .number()
@@ -459,15 +459,15 @@ export const EditFileInputSchema = z.strictObject({
         .array(z.strictObject({
         oldText: z
             .string()
-            .describe('Exact literal string to replace — must match character-for-character including whitespace and indentation. Include 3–5 lines of surrounding context to uniquely identify the location.'),
+            .describe('Exact literal string to replace (character-for-character). Include 3–5 lines of context for unique targeting.'),
         newText: z
             .string()
-            .describe('Replacement string — preserve the indentation style of surrounding code.'),
+            .describe('Replacement string. Preserve surrounding indentation style.'),
     }))
         .min(1, 'Min 1 edit required')
         .describe('List of replacements to apply sequentially. Each edit replaces the first occurrence of oldText.'),
-    dryRun: defaultFalseBoolean('Preview edits without writing. Check unmatchedEdits in the response to verify all oldText values were found.'),
-    ignoreWhitespace: defaultFalseBoolean('Ignore leading/trailing whitespace and treat all whitespace sequences as equivalent when matching oldText.'),
+    dryRun: defaultFalseBoolean('Preview edits without writing. Check `unmatchedEdits` in response.'),
+    ignoreWhitespace: defaultFalseBoolean('Treat all whitespace sequences as equivalent when matching oldText.'),
 });
 export const EditFileOutputSchema = z.strictObject({
     ok: z.boolean(),
@@ -564,7 +564,7 @@ export const ApplyPatchInputSchema = z.strictObject({
     path: RequiredPathSchema.describe('Path to file to patch'),
     patch: z
         .string()
-        .describe('Unified diff content to apply — must include @@ hunk headers. Generate with `diff_files`.'),
+        .describe('Unified diff with @@ hunk headers. Generate with `diff_files`.'),
     fuzzFactor: z
         .number()
         .int({ error: 'Must be integer' })
@@ -581,7 +581,7 @@ export const ApplyPatchInputSchema = z.strictObject({
         .boolean()
         .optional()
         .default(false)
-        .describe('Validate the patch can be applied without writing. Check `applied` in the response before committing.'),
+        .describe('Validate patch without writing. Check `applied` before committing.'),
 });
 export const ApplyPatchOutputSchema = z.strictObject({
     ok: z.boolean(),
@@ -602,18 +602,18 @@ export const SearchAndReplaceInputSchema = z.strictObject({
     searchPattern: z
         .string()
         .min(1, 'Search pattern required')
-        .describe('Text to search for. Matched literally by default; treated as RE2 regex when isRegex is true.'),
+        .describe('Text to search for. Literal by default; RE2 regex when `isRegex=true`.'),
     replacement: z.string().describe('Replacement text'),
-    isRegex: defaultFalseBoolean('Treat searchPattern as a RE2 regular expression. Supports capture group references ($1, $2) in replacement.'),
+    isRegex: defaultFalseBoolean('Treat searchPattern as RE2 regex. Supports capture groups ($1, $2) in replacement.'),
     dryRun: defaultFalseBoolean('Preview matches without writing. Check changedFiles and matches in the response before committing.'),
     includeHidden: z
         .boolean()
         .optional()
-        .describe('Include hidden files and directories (starting with .) in the search scope. Default: false.'),
+        .describe('Include hidden files/directories (starting with .). Default: false.'),
     includeIgnored: z
         .boolean()
         .optional()
-        .describe('Include files and directories ignored by .gitignore rules (e.g. node_modules, dist). Default: false.'),
+        .describe('Include .gitignore-ignored files (node_modules, dist). Default: false.'),
     returnDiff: z
         .boolean()
         .optional()

package/dist/server/bootstrap.d.ts

@@ -1,6 +1,24 @@
 import * as http from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { ServerOptions } from './types.js';
+import type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
+export interface ServerOptions {
+    allowCwd?: boolean;
+    cliAllowedDirs?: string[];
+}
+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 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;
 export declare function createServer(options?: ServerOptions): Promise<McpServer>;
 export declare function startServer(server: McpServer): Promise<void>;
 export declare function startHttpServer(port: number, options: ServerOptions): Promise<http.Server>;
+export {};

package/dist/server/bootstrap.js

@@ -6,19 +6,104 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { registerCompletions } from '../completions.js';
 import { DEFAULT_LOG_LEVEL, parseEnvInt, REQUIRED_MCP_PROTOCOL_VERSION, } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { createInMemoryResourceStore } from '../lib/resource-store.js';
+import { isRecord } from '../lib/utils.js';
+import { registerCompletions } from '../completions.js';
 import { pkgInfo } from '../pkg-info.js';
 import { registerGetHelpPrompt } from '../prompts.js';
 import { registerInstructionResource, registerMetricsResource, registerResultResources, registerToolCatalogResource, registerToolInfoResource, registerWorkflowGuideResource, } from '../resources.js';
 import { buildServerInstructions } from '../resources/generated-instructions.js';
 import { registerAllTools } from '../tools.js';
 import { withDefaultIcons } from '../tools/shared.js';
-import { buildServerCapabilities, supportsTaskToolRequests, } from './capabilities.js';
-import { createLoggingState } from './logging.js';
 import { RootsManager } from './roots-manager.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();
+}
+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));
+    });
+}
 const { version: SERVER_VERSION, description: SERVER_DESCRIPTION, homepage: SERVER_HOMEPAGE, } = pkgInfo;
 const rootsManagers = new WeakMap();
 function getRootsManager(server) {
@@ -242,9 +327,11 @@ export async function startHttpServer(port, options) {
             if (typeof authHeader === 'string' &&
                 authHeader.startsWith(bearerPrefix)) {
                 const userKey = authHeader.slice(bearerPrefix.length);
-                const expectedHash = createHash('sha256').update(apiKey).digest();
-                const actualHash = createHash('sha256').update(userKey).digest();
-                authorized = timingSafeEqual(expectedHash, actualHash);
+                if (userKey.length <= 4096) {
+                    const expectedHash = createHash('sha256').update(apiKey).digest();
+                    const actualHash = createHash('sha256').update(userKey).digest();
+                    authorized = timingSafeEqual(expectedHash, actualHash);
+                }
             }
             if (!authorized) {
                 res.writeHead(401, {
@@ -283,7 +370,7 @@ export async function startHttpServer(port, options) {
                 }
                 const body = await readRequestBody(req);
                 if (isInitializeRequest(body)) {
-                    const maxSessions = parseInt(process.env['FILESYSTEM_MCP_MAX_HTTP_SESSIONS'] ?? '', 10) || 100;
+                    const maxSessions = parseEnvInt('FILESYSTEM_MCP_MAX_HTTP_SESSIONS', 100, 1, 10_000);
                     if (sessions.size >= maxSessions) {
                         sendJsonRpcError(res, 503, -32000, 'Too many sessions');
                         return;
@@ -316,8 +403,15 @@ export async function startHttpServer(port, options) {
                 }
             }
             else {
-                res.writeHead(405, { Allow: 'GET, POST, DELETE' });
-                res.end('Method Not Allowed');
+                res.writeHead(405, {
+                    Allow: 'GET, POST, DELETE',
+                    'Content-Type': 'application/json',
+                });
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    error: { code: -32000, message: 'Method Not Allowed' },
+                    id: null,
+                }));
             }
         }
         catch (error) {

package/dist/server/roots-manager.d.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { type LoggingState } from './logging.js';
-import type { ServerOptions } from './types.js';
+import { type LoggingState } from './bootstrap.js';
+import type { ServerOptions } from './bootstrap.js';
 export declare class RootsManager {
     private rootsUpdateTimeout;
     private rootDirectories;

package/dist/server/roots-manager.js

@@ -3,9 +3,9 @@ import { InitializedNotificationSchema, RootsListChangedNotificationSchema, } fr
 import { z } from 'zod';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
-import { getAllowedDirectories, getValidRootDirectories, isPathWithinDirectories, normalizePath, setAllowedDirectoriesResolved, } from '../lib/path-validation.js';
-import { isRecord } from '../lib/type-guards.js';
-import { logToMcp } from './logging.js';
+import { getAllowedDirectories, getValidRootDirectories, isPathWithinDirectories, normalizePath, setAllowedDirectoriesResolved, } from '../lib/paths.js';
+import { isRecord } from '../lib/utils.js';
+import { logToMcp } from './bootstrap.js';
 const ROOTS_TIMEOUT_MS = 5000;
 const ROOTS_DEBOUNCE_MS = 100;
 function normalizeCLIDirectories(dirs) {

package/dist/tools/apply-patch.js

@@ -4,7 +4,7 @@ import { applyPatch } from 'diff';
 import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
-import { validateExistingPath } from '../lib/path-validation.js';
+import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
@@ -12,8 +12,8 @@ export const APPLY_PATCH_TOOL = {
     name: 'apply_patch',
     title: 'Apply Patch',
     description: 'Apply a unified diff patch to a file. ' +
-        'Generate the patch with `diff_files`, then validate with `dryRun: true` before writing. ' +
-        'On failure, regenerate a fresh patch via `diff_files` against the current file content and retry.',
+        'Workflow: `diff_files` \u2192 `apply_patch(dryRun:true)` \u2192 `apply_patch`. ' +
+        'On failure, regenerate the patch from current file content.',
     inputSchema: ApplyPatchInputSchema,
     outputSchema: ApplyPatchOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
@@ -36,6 +36,7 @@ function assertPatchHasHunks(patch) {
 async function handleApplyPatch(args, signal) {
     const maxFileSize = MAX_TEXT_FILE_SIZE;
     const validPath = await validateExistingPath(args.path, signal);
+    assertAllowedFileAccess(args.path, validPath);
     const stats = await withAbort(fs.stat(validPath), signal);
     assertPatchTargetSizeWithinLimit(validPath, stats.size, maxFileSize);
     const content = await fs.readFile(validPath, { encoding: 'utf-8', signal });

package/dist/tools/calculate-hash.js

@@ -4,11 +4,11 @@ import { createHash } from 'node:crypto';
 import { createReadStream } from 'node:fs';
 import { PARALLEL_CONCURRENCY } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
-import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations/gitignore.js';
-import { globEntries } from '../lib/file-operations/glob-engine.js';
+import { isIgnoredByGitignore, loadRootGitignore, } from '../lib/file-operations/core.js';
+import { globEntries } from '../lib/file-operations/traversal.js';
 import { assertNotAborted, withAbort } from '../lib/fs-helpers.js';
-import { validateExistingPath } from '../lib/path-validation.js';
-import { reportPeriodicProgress } from '../lib/progress-reporting.js';
+import { validateExistingPath } from '../lib/paths.js';
+import { reportPeriodicProgress } from '../lib/utils.js';
 import { CalculateHashInputSchema, CalculateHashOutputSchema, } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';

package/dist/tools/create-directory.js

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs/promises';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { withAbort } from '../lib/fs-helpers.js';
-import { validatePathForWrite } from '../lib/path-validation.js';
+import { validatePathForWrite } from '../lib/paths.js';
 import { CreateDirectoryInputSchema, CreateDirectoryOutputSchema, } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, IDEMPOTENT_WRITE_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';