@j0hanz/filesystem-mcp 1.13.0 → 1.13.2

package/dist/completions.d.ts

@@ -1,13 +1,2 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-interface CompletionResult {
-    values: string[];
-    total?: number;
-    hasMore?: boolean;
-}
-interface CompletionOptions {
-    argumentName?: string;
-    contextArguments?: Record<string, string>;
-}
-export declare function getPathCompletions(currentValue: string, options?: CompletionOptions): Promise<CompletionResult>;
 export declare function registerCompletions(server: McpServer, instructions?: string): void;
-export {};

package/dist/completions.js

@@ -47,6 +47,9 @@ const PATH_ARGUMENTS = new Set([
 const DESTINATION_CONTEXT_KEYS = ['source', 'path', 'cwd', 'root'];
 const PRIMARY_PATH_CONTEXT_KEYS = ['path', 'cwd', 'root'];
 const DEFAULT_CONTEXT_KEYS = ['path', 'source', 'cwd', 'root'];
+const ENUM_ARGUMENT_VALUES = new Map([
+    ['sortby', ['modified', 'name', 'path', 'size', 'type']],
+]);
 function isPathLikeArgumentName(argName) {
     return (PATH_ARGUMENTS.has(argName) ||
         argName.endsWith('paths') ||
@@ -56,6 +59,16 @@ function isPathLikeArgumentName(argName) {
         argName.endsWith('dirs') ||
         argName.endsWith('dir'));
 }
+function getEnumCompletions(argName, currentValue) {
+    const values = ENUM_ARGUMENT_VALUES.get(argName);
+    if (!values)
+        return undefined;
+    const prefix = currentValue.toLowerCase();
+    const filtered = prefix
+        ? values.filter((v) => v.startsWith(prefix))
+        : [...values];
+    return buildCompletionResult(filtered);
+}
 function isTemplateVariableChar(char) {
     const code = char.charCodeAt(0);
     const isDigit = code >= 48 && code <= 57;
@@ -396,7 +409,7 @@ function findMatchingRoots(searchDir, prefix, allowed) {
         return path.basename(root).toLowerCase().startsWith(lowerPrefix);
     });
 }
-export async function getPathCompletions(currentValue, options = {}) {
+async function getPathCompletions(currentValue, options = {}) {
     const allowed = getAllowedDirectories();
     try {
         const contextBase = await resolveContextBaseDirectory(options.argumentName ?? '', options.contextArguments, allowed);
@@ -452,6 +465,10 @@ export function registerCompletions(server, instructions = '') {
                 : toolNameValues;
             return buildCompletionResponse(buildCompletionResult(filtered));
         }
+        const enumResult = getEnumCompletions(argName, argument.value);
+        if (enumResult) {
+            return buildCompletionResponse(enumResult);
+        }
         const isPathArg = isPathLikeArgumentName(argName) ||
             isPathArgumentFromReference(argName, ref);
         if (!isPathArg) {

package/dist/lib/constants.d.ts

@@ -1,7 +1,6 @@
 export declare function parseTrueEnvFlag(value: string | undefined): boolean;
 export declare function parseEnvInt(envVar: string, defaultValue: number, min: number, max: number): number;
 export declare const DEFAULT_LOG_LEVEL: "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
-export declare const REQUIRED_MCP_PROTOCOL_VERSION = "2025-11-25";
 export declare const DEFAULT_TASK_TTL_MS: number;
 export declare const MAX_TASK_TTL_MS: number;
 export declare const MAX_CONCURRENT_TASKS: number;

package/dist/lib/constants.js

@@ -70,7 +70,6 @@ function parseEnvLogLevel(envVar, defaultValue) {
     return defaultValue;
 }
 export const DEFAULT_LOG_LEVEL = parseEnvLogLevel('FILESYSTEM_MCP_LOG_LEVEL', 'info');
-export const REQUIRED_MCP_PROTOCOL_VERSION = '2025-11-25';
 // Default TTL for MCP tasks when the client does not specify one (5 minutes).
 export const DEFAULT_TASK_TTL_MS = 5 * 60 * 1000;
 export const MAX_TASK_TTL_MS = parseEnvInt('FILESYSTEM_MCP_MAX_TASK_TTL_MS', 60 * 60 * 1000, 1_000, 24 * 60 * 60 * 1000);

package/dist/lib/errors.d.ts

@@ -17,7 +17,6 @@ export declare class McpError extends Error {
     path?: string | undefined;
     details?: Record<string, unknown> | undefined;
     constructor(code: ErrorCode, message: string, path?: string | undefined, details?: Record<string, unknown> | undefined, cause?: unknown);
-    static fromError(code: ErrorCode, message: string, originalError: unknown, path?: string, details?: Record<string, unknown>): McpError;
 }
 export declare function createDetailedError(error: unknown, path?: string, additionalDetails?: Record<string, unknown>): DetailedError;
 export declare function formatDetailedError(error: DetailedError): string;

package/dist/lib/errors.js

@@ -173,13 +173,6 @@ export class McpError extends Error {
         this.name = 'McpError';
         Object.setPrototypeOf(this, McpError.prototype);
     }
-    static fromError(code, message, originalError, path, details) {
-        const mcpError = new McpError(code, message, path, details, originalError);
-        if (originalError instanceof Error && originalError.stack) {
-            mcpError.stack = `${String(mcpError.stack)}\nCaused by: ${originalError.stack}`;
-        }
-        return mcpError;
-    }
 }
 const ERROR_SUGGESTIONS = {
     [ErrorCode.E_ACCESS_DENIED]: 'Check that the path is within an allowed directory. Use roots to see available workspace roots.',

package/dist/lib/file-operations/core.d.ts

@@ -9,11 +9,11 @@ export interface DirentLike {
     isSymbolicLink(): boolean;
 }
 export type EntryType = 'file' | 'directory' | 'symlink' | 'other';
-export interface IndexedValue<T> {
+interface IndexedValue<T> {
     index: number;
     value: T;
 }
-export interface IndexedError {
+interface IndexedError {
     index: number;
     error: Error;
 }
@@ -50,3 +50,4 @@ export declare function isIgnoredByGitignore(matcher: Ignore, root: string, abso
     isDirectory?: boolean;
     relativePath?: string;
 }): boolean;
+export {};

package/dist/lib/file-operations/search.d.ts

@@ -1,21 +1,5 @@
-import * as fsp from 'node:fs/promises';
 import { z } from 'zod';
-import type { ContentMatch, SearchContentResult, SearchFilesResult } from '../../config.js';
-export declare const MatcherOptionsSchema: z.ZodObject<{
-    caseSensitive: z.ZodBoolean;
-    wholeWord: z.ZodBoolean;
-    isLiteral: z.ZodBoolean;
-    multiline: 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;
-    contextLines: number;
-}
+import type { SearchContentResult, SearchFilesResult } from '../../config.js';
 declare const SearchOptionsSchema: z.ZodObject<{
     filePattern: z.ZodString;
     excludePatterns: z.ZodArray<z.ZodString>;
@@ -41,40 +25,6 @@ export interface SearchContentOptions extends Partial<ResolvedOptions> {
         current: number;
     }) => void;
 }
-type BinaryDetector = (resolvedPath: string, handle: fsp.FileHandle, signal?: AbortSignal) => Promise<boolean>;
-export interface ScanRequest {
-    type: 'scan';
-    id: number;
-    resolvedPath: string;
-    requestedPath: string;
-    pattern: string;
-    matcherOptions: MatcherOptions;
-    scanOptions: ScanFileOptions;
-    maxMatches: number;
-}
-export interface ScanResult {
-    type: 'result';
-    id: number;
-    result: {
-        matches: readonly ContentMatch[];
-        matched: boolean;
-        skippedTooLarge: boolean;
-        skippedBinary: boolean;
-    };
-}
-export interface ScanError {
-    type: 'error';
-    id: number;
-    error: string;
-}
-export type WorkerResponse = ScanResult | ScanError;
-interface WorkerScanResult {
-    matches: readonly ContentMatch[];
-    matched: boolean;
-    skippedTooLarge: boolean;
-    skippedBinary: boolean;
-}
-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 {
@@ -93,12 +43,5 @@ interface SearchFilesOptions {
         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.js

@@ -68,12 +68,6 @@ import { assertAllowedFileAccess, isPathWithinDirectories, isSensitivePath, norm
 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(),
-    multiline: z.boolean(),
-});
 function countRegexLineMatches(regex, line) {
     regex.lastIndex = 0;
     let count = 0;
@@ -91,7 +85,7 @@ function buildRegexPattern(pattern, options) {
     const escaped = options.isLiteral ? escapeLiteral(pattern) : pattern;
     return options.wholeWord ? `\\b${escaped}\\b` : escaped;
 }
-export function validatePattern(pattern, options) {
+function validatePattern(pattern, options) {
     if (options.isLiteral && pattern.length === 0)
         return;
     if (options.isLiteral && !options.wholeWord)
@@ -130,7 +124,7 @@ function buildRegexMatcher(final, caseSensitive, multiline) {
     const regex = new RE2(final, flags);
     return (line) => countRegexLineMatches(regex, line);
 }
-export function buildMatcher(pattern, options) {
+function buildMatcher(pattern, options) {
     if (options.isLiteral && pattern.length === 0)
         return () => 0;
     if (options.isLiteral && !options.wholeWord) {
@@ -751,7 +745,7 @@ async function executeParallel(files, pattern, opts, signal, summary) {
     return matches;
 }
 // --- Entry Points ---
-export async function scanFileInWorker(resolvedPath, requestedPath, matcher, options, maxMatches, isCancelled, isBinaryDetector) {
+async function scanFileInWorker(resolvedPath, requestedPath, matcher, options, maxMatches, isCancelled, isBinaryDetector) {
     // Direct scan used by worker script
     const res = await scanFileResolved(resolvedPath, requestedPath, matcher, options, undefined, maxMatches, isBinaryDetector);
     return {
@@ -1051,7 +1045,7 @@ const SORT_COMPARATORS = {
     path: (a, b) => comparePathThenName(a, b),
     name: (a, b) => compareNameThenPath(a, b),
 };
-export function sortSearchResults(results, sortBy) {
+function sortSearchResults(results, sortBy) {
     if (sortBy === 'name') {
         stableSortByDerivedString(results, (item) => path.basename(item.path ?? ''), (left, right) => comparePathThenName(left, right));
         return;

package/dist/lib/file-operations/traversal.d.ts

@@ -6,7 +6,7 @@ interface GlobEntry {
     dirent: DirentLike;
     stats?: Stats;
 }
-export interface GlobEntriesOptions {
+interface GlobEntriesOptions {
     cwd: string;
     pattern: string;
     excludePatterns: readonly string[];
@@ -20,7 +20,7 @@ export interface GlobEntriesOptions {
     suppressErrors?: boolean;
 }
 export declare function globEntries(options: GlobEntriesOptions): AsyncGenerator<GlobEntry>;
-export interface GlobConfig {
+interface GlobConfig {
     cwd: string;
     pattern: string;
     excludePatterns?: readonly string[];

package/dist/lib/fs-helpers.d.ts

@@ -43,11 +43,10 @@ interface ReadFileResult {
     linesRead?: number;
     hasMoreLines?: boolean;
 }
-declare function headFile(handle: fsp.FileHandle, numLines: number, encoding?: BufferEncoding, maxBytesRead?: number, signal?: AbortSignal): Promise<string>;
 export declare function readFileWithStats(filePath: string, validPath: string, stats: Stats, options?: ReadFileOptions): Promise<ReadFileResult>;
 export declare function readFile(filePath: string, options?: ReadFileOptions): Promise<ReadFileResult>;
 export declare function atomicWriteFile(filePath: string, content: string, options?: {
     encoding?: BufferEncoding;
     signal?: AbortSignal | undefined;
 }): Promise<void>;
-export { headFile };
+export {};

package/dist/lib/fs-helpers.js

@@ -667,4 +667,3 @@ export async function atomicWriteFile(filePath, content, options = {}) {
         throw error;
     }
 }
-export { headFile };

package/dist/lib/paths.d.ts

@@ -1,5 +1,4 @@
 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;
@@ -15,7 +14,6 @@ export interface AllowedDirectoriesState {
  */
 export declare function normalizePath(p: string): string;
 export declare function withAllowedDirectoriesState<T>(state: AllowedDirectoriesState, run: () => T): T;
-export declare function getAllowedDirectoriesState(): AllowedDirectoriesState;
 export declare function setAllowedDirectoriesStateResolved(state: AllowedDirectoriesState): void;
 export declare function getAllowedDirectories(): string[];
 export declare function isAllowedDirectoryRoot(normalizedPath: string): boolean;
@@ -24,7 +22,6 @@ export declare function resolveAllowedDirectoriesState(dirs: readonly string[],
 export declare function setAllowedDirectoriesResolved(dirs: readonly string[], signal?: AbortSignal): Promise<void>;
 export declare function getReservedDeviceNameForPath(requestedPath: string): string | undefined;
 export declare function isWindowsDriveRelativePath(requestedPath: string): boolean;
-export declare function toAccessDeniedWithHint(requestedPath: string, resolvedPath: string, normalizedResolved: string): McpError;
 interface ValidatedPathDetails {
     requestedPath: string;
     resolvedPath: string;

package/dist/lib/paths.js

@@ -252,9 +252,6 @@ function getActiveAllowedDirectoriesState() {
 export function withAllowedDirectoriesState(state, run) {
     return allowedDirectoriesContext.run(cloneAllowedDirectoriesState(state), run);
 }
-export function getAllowedDirectoriesState() {
-    return cloneAllowedDirectoriesState(getActiveAllowedDirectoriesState());
-}
 export function setAllowedDirectoriesStateResolved(state) {
     setAllowedDirectoriesState(state.primary, state.expanded);
 }
@@ -453,7 +450,7 @@ function toMcpError(requestedPath, error) {
     }
     return new McpError(ErrorCode.E_NOT_FOUND, `Path is not accessible: ${requestedPath}`, requestedPath, { originalCode: code, originalMessage }, error);
 }
-export function toAccessDeniedWithHint(requestedPath, resolvedPath, normalizedResolved) {
+function toAccessDeniedWithHint(requestedPath, resolvedPath, normalizedResolved) {
     const suggestion = buildAllowedDirectoriesHint();
     return new McpError(ErrorCode.E_ACCESS_DENIED, `Access denied: Path '${requestedPath}' is outside allowed directories.\n${suggestion}`, requestedPath, { resolvedPath, normalizedResolvedPath: normalizedResolved });
 }

package/dist/lib/utils.d.ts

@@ -5,15 +5,15 @@ export declare function debounce<Args extends unknown[]>(func: (...args: Args) =
 };
 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 {
+interface ProgressPayload {
     current: number;
     total?: number;
 }
-export type ProgressCallback = ((progress: ProgressPayload) => void) | undefined;
-export interface PeriodicProgressOptions {
+type ProgressCallback = ((progress: ProgressPayload) => void) | undefined;
+interface PeriodicProgressOptions {
     total?: number;
     throttleModulo?: number;
     force?: boolean;
 }
 export declare function reportPeriodicProgress(onProgress: ProgressCallback, current: number, options?: PeriodicProgressOptions): void;
+export {};

package/dist/lib/utils.js

@@ -14,11 +14,7 @@ export function debounce(func, waitMs) {
             func(...args);
         }, waitMs);
         // Unref if in Node environment to not block process exit
-        const nodeTimeout = timeoutId;
-        if (typeof nodeTimeout === 'object' &&
-            typeof nodeTimeout.unref === 'function') {
-            nodeTimeout.unref();
-        }
+        timeoutId.unref();
     };
     debounced.cancel = () => {
         if (timeoutId !== undefined) {
@@ -39,11 +35,6 @@ export function omitOptionKeys(input, keys) {
     }
     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;

package/dist/resources/tool-info.js

@@ -98,6 +98,9 @@ function summarizeSchemaType(schema) {
     if (Array.isArray(schema.enum) && schema.enum.length > 0) {
         return `enum(${schema.enum.map((value) => JSON.stringify(value)).join(', ')})`;
     }
+    if (schema.const !== undefined) {
+        return `const(${JSON.stringify(schema.const)})`;
+    }
     if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
         return schema.anyOf.map(summarizeSchemaType).join(' | ');
     }
@@ -105,11 +108,18 @@ function summarizeSchemaType(schema) {
         return schema.oneOf.map(summarizeSchemaType).join(' | ');
     }
     if (schema.type === 'array') {
+        if (Array.isArray(schema.prefixItems) && schema.prefixItems.length > 0) {
+            const itemTypes = schema.prefixItems.map(summarizeSchemaType).join(', ');
+            return `tuple<${itemTypes}>`;
+        }
         const itemType = schema.items
             ? summarizeSchemaType(schema.items)
             : 'unknown';
         return `array<${itemType}>`;
     }
+    if (schema.type === 'object' && schema.additionalProperties === false) {
+        return 'object (strict)';
+    }
     if (typeof schema.type === 'string' && schema.type.length > 0) {
         return schema.type;
     }
@@ -129,6 +139,9 @@ function buildSchemaFieldLines(label, schema) {
         jsonSchema.description.length > 0) {
         lines.push(`- Schema constraints: ${jsonSchema.description}`);
     }
+    if (jsonSchema.additionalProperties === false) {
+        lines.push('- Unknown fields are rejected (`additionalProperties: false`).');
+    }
     if (fieldNames.length === 0) {
         lines.push('- object with no fields', `</${label}>`);
         return lines;

package/dist/schemas.d.ts

@@ -12,28 +12,6 @@ interface TreeEntry {
     size?: number | undefined;
     children?: TreeEntry[] | undefined;
 }
-export declare const ToolErrorResponseSchema: z.ZodObject<{
-    ok: z.ZodLiteral<false>;
-    error: z.ZodObject<{
-        code: z.ZodEnum<{
-            readonly E_ACCESS_DENIED: "E_ACCESS_DENIED";
-            readonly E_NOT_FOUND: "E_NOT_FOUND";
-            readonly E_NOT_FILE: "E_NOT_FILE";
-            readonly E_NOT_DIRECTORY: "E_NOT_DIRECTORY";
-            readonly E_TOO_LARGE: "E_TOO_LARGE";
-            readonly E_TIMEOUT: "E_TIMEOUT";
-            readonly E_CANCELLED: "E_CANCELLED";
-            readonly E_INVALID_PATTERN: "E_INVALID_PATTERN";
-            readonly E_INVALID_INPUT: "E_INVALID_INPUT";
-            readonly E_PERMISSION_DENIED: "E_PERMISSION_DENIED";
-            readonly E_SYMLINK_NOT_ALLOWED: "E_SYMLINK_NOT_ALLOWED";
-            readonly E_UNKNOWN: "E_UNKNOWN";
-        }>;
-        message: z.ZodString;
-        path: z.ZodOptional<z.ZodString>;
-        suggestion: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
 declare const HeadLinesSchema: z.ZodOptional<z.ZodInt>;
 declare const TailLinesSchema: z.ZodOptional<z.ZodInt>;
 declare const LineNumberSchema: z.ZodInt;

package/dist/schemas.js

@@ -48,10 +48,6 @@ const ErrorSchema = z.strictObject({
     path: z.string().optional().describe('Relevant path'),
     suggestion: z.string().optional().describe('Fix suggestion'),
 });
-export const ToolErrorResponseSchema = z.strictObject({
-    ok: z.literal(false).describe('Operation failed'),
-    error: ErrorSchema.describe('Error details'),
-});
 const HeadLinesSchema = z
     .int({ error: 'Must be integer' })
     .min(1, 'Min: 1')

package/dist/server/bootstrap.d.ts

@@ -5,20 +5,10 @@ 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

@@ -41,7 +41,7 @@ function detectTaskToolSupport() {
     }
     return cachedTaskToolSupport;
 }
-export function buildServerCapabilities(options = {}) {
+function buildServerCapabilities(options = {}) {
     const capabilities = {
         logging: {},
         resources: {},
@@ -61,7 +61,7 @@ export function buildServerCapabilities(options = {}) {
     }
     return capabilities;
 }
-export function supportsTaskToolRequests() {
+function supportsTaskToolRequests() {
     return detectTaskToolSupport();
 }
 const MCP_LOGGER_NAME = 'filesystem-mcp';
@@ -75,7 +75,7 @@ const LOG_LEVEL_ORDER = {
     alert: 6,
     emergency: 7,
 };
-export function createLoggingState(minimumLevel = 'debug') {
+function createLoggingState(minimumLevel = 'debug') {
     return { minimumLevel };
 }
 function canSendMcpLogs(server) {

package/dist/tools/create-directory.d.ts

@@ -1,7 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { z } from 'zod';
-import { CreateDirectoryInputSchema, CreateDirectoryOutputSchema } from '../schemas.js';
-import { type ToolContract, type ToolRegistrationOptions, type ToolResponse } from './shared.js';
+import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const CREATE_DIRECTORY_TOOL: ToolContract;
-export declare function handleCreateDirectory(args: z.infer<typeof CreateDirectoryInputSchema>, signal?: AbortSignal): Promise<ToolResponse<z.infer<typeof CreateDirectoryOutputSchema>>>;
 export declare function registerCreateDirectoryTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/create-directory.js

@@ -16,7 +16,7 @@ export const CREATE_DIRECTORY_TOOL = {
     nuances: ['Succeeds silently if the directory already exists (idempotent).'],
     taskSupport: 'forbidden',
 };
-export async function handleCreateDirectory(args, signal) {
+async function handleCreateDirectory(args, signal) {
     const allPaths = [];
     if (args.path)
         allPaths.push(args.path);

package/dist/tools/edit-file.d.ts

@@ -1,10 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { z } from 'zod';
-import { EditFileInputSchema, EditFileOutputSchema } from '../schemas.js';
-import { type ToolContract, type ToolRegistrationOptions, type ToolResponse } from './shared.js';
+import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const EDIT_FILE_TOOL: ToolContract;
-type EditInput = z.infer<typeof EditFileInputSchema>;
-type EditOutput = z.infer<typeof EditFileOutputSchema>;
-export declare function handleEditFile(args: EditInput, signal?: AbortSignal): Promise<ToolResponse<EditOutput>>;
 export declare function registerEditFileTool(server: McpServer, options?: ToolRegistrationOptions): void;
-export {};

package/dist/tools/edit-file.js

@@ -185,7 +185,7 @@ function buildEditCompletionMessage(args, result) {
     const added = structuredContent.linesAdded ?? 0;
     const removed = structuredContent.linesRemoved ?? 0;
     const dry = args.dryRun ? 'dry run ' : '';
-    return `🛠 edit: ${name} • ${dry}+${added} -${removed}`;
+    return `🛠 edit: ${name} • ${dry} +${added} -${removed}`;
 }
 async function applyEdits(content, edits, ignoreWhitespace) {
     let newContent = content;
@@ -205,7 +205,7 @@ async function applyEdits(content, edits, ignoreWhitespace) {
     }
     return finalizeEditResult(content, newContent, appliedEdits, unmatchedEdits, lineRange);
 }
-export async function handleEditFile(args, signal) {
+async function handleEditFile(args, signal) {
     const { validPath, content } = await loadEditableFile(args.path, signal);
     const editResult = await applyEdits(content, args.edits, args.ignoreWhitespace);
     const structured = buildStructuredEditOutput(validPath, editResult);

package/dist/tools/move-file.d.ts

@@ -1,7 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { z } from 'zod';
-import { MoveFileInputSchema, MoveFileOutputSchema } from '../schemas.js';
-import { type ToolContract, type ToolRegistrationOptions, type ToolResponse } from './shared.js';
+import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const MOVE_FILE_TOOL: ToolContract;
-export declare function handleMoveFile(args: z.infer<typeof MoveFileInputSchema>, signal?: AbortSignal): Promise<ToolResponse<z.infer<typeof MoveFileOutputSchema>>>;
 export declare function registerMoveFileTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/move-file.js

@@ -19,7 +19,7 @@ export const MOVE_FILE_TOOL = {
     ],
     taskSupport: 'forbidden',
 };
-export async function handleMoveFile(args, signal) {
+async function handleMoveFile(args, signal) {
     const sources = args.sources ?? (args.source ? [args.source] : []);
     if (sources.length === 0) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'No sources provided.');

package/dist/tools/replace-in-files.d.ts

@@ -1,13 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { z } from 'zod';
-import { SearchAndReplaceInputSchema, SearchAndReplaceOutputSchema } from '../schemas.js';
-import { type ToolContract, type ToolRegistrationOptions, type ToolResponse } from './shared.js';
+import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const SEARCH_AND_REPLACE_TOOL: ToolContract;
-type SearchAndReplaceArgs = z.infer<typeof SearchAndReplaceInputSchema>;
-type SearchAndReplaceOutput = z.infer<typeof SearchAndReplaceOutputSchema>;
-export declare function handleSearchAndReplace(args: SearchAndReplaceArgs, signal?: AbortSignal, onProgress?: (progress: {
-    total?: number;
-    current: number;
-}) => void): Promise<ToolResponse<SearchAndReplaceOutput>>;
 export declare function registerSearchAndReplaceTool(server: McpServer, options?: ToolRegistrationOptions): void;
-export {};

package/dist/tools/replace-in-files.js

@@ -1,6 +1,8 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { Buffer } from 'node:buffer';
+import { performance } from 'node:perf_hooks';
 import { createTwoFilesPatch } from 'diff';
 import RE2 from 're2';
 import safeRegex from 'safe-regex2';
@@ -11,7 +13,7 @@ import { atomicWriteFile } from '../lib/fs-helpers.js';
 import { validateExistingPath, validatePathForWrite } from '../lib/paths.js';
 import { reportPeriodicProgress } from '../lib/utils.js';
 import { SearchAndReplaceInputSchema, SearchAndReplaceOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createToolProgressSession, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, resolveFinalProgressCurrent, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, createToolProgressSession, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 export const SEARCH_AND_REPLACE_TOOL = {
     name: 'search_and_replace',
@@ -110,6 +112,13 @@ class LiteralReplacementMatcher {
         return content.replaceAll(this.searchPattern, () => replacement);
     }
 }
+const replaceContextStorage = new AsyncLocalStorage();
+function getReplaceContext() {
+    const ctx = replaceContextStorage.getStore();
+    if (!ctx)
+        throw new Error('Replace context not found in AsyncLocalStorage');
+    return ctx;
+}
 function buildReplacementPlan(content, replacement, matcher) {
     const matchCount = matcher.count(content);
     if (matchCount === 0) {
@@ -124,8 +133,8 @@ function buildReplacementPlan(content, replacement, matcher) {
 function formatFileTooLargeError(filePath, size, maxFileSize) {
     return `File too large: ${filePath} (${size} bytes > ${maxFileSize} bytes)`;
 }
-async function processEntry(entryPath, context) {
-    const { options, replacement, matcher, maxFileSize, signal, summary } = context;
+async function processEntry(entryPath) {
+    const { options, signal, summary } = getReplaceContext();
     let validPath;
     try {
         validPath = await validatePathForWrite(entryPath, signal);
@@ -139,12 +148,7 @@ async function processEntry(entryPath, context) {
         return;
     }
     try {
-        const plan = await readReplacementPlan(validPath, {
-            matcher,
-            replacement,
-            maxFileSize,
-            signal,
-        });
+        const plan = await readReplacementPlan(validPath);
         if (!plan) {
             return;
         }
@@ -172,19 +176,20 @@ async function processEntry(entryPath, context) {
         });
     }
 }
-async function readReplacementPlan(validPath, context) {
+async function readReplacementPlan(validPath) {
+    const { matcher, replacement, maxFileSize, signal } = getReplaceContext();
     let fileHandle;
     try {
         const fd = await fs.open(validPath, 'r');
         fileHandle = fd;
         const stats = await fileHandle.stat();
-        if (stats.size > context.maxFileSize) {
-            throw new Error(formatFileTooLargeError(validPath, stats.size, context.maxFileSize));
+        if (stats.size > maxFileSize) {
+            throw new Error(formatFileTooLargeError(validPath, stats.size, maxFileSize));
         }
         let content;
-        if (context.matcher.testBuffer) {
-            const buffer = await fileHandle.readFile({ signal: context.signal });
-            if (!context.matcher.testBuffer(buffer)) {
+        if (matcher.testBuffer) {
+            const buffer = await fileHandle.readFile({ signal });
+            if (!matcher.testBuffer(buffer)) {
                 return undefined;
             }
             content = buffer.toString('utf-8');
@@ -192,10 +197,10 @@ async function readReplacementPlan(validPath, context) {
         else {
             content = await fileHandle.readFile({
                 encoding: 'utf-8',
-                signal: context.signal,
+                signal,
             });
         }
-        return buildReplacementPlan(content, context.replacement, context.matcher);
+        return buildReplacementPlan(content, replacement, matcher);
     }
     finally {
         if (fileHandle) {
@@ -211,10 +216,13 @@ async function maybeAppendPatchDiff(summary, params) {
         return;
     }
     const patch = await new Promise((resolve) => {
-        createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified', {
-            callback: (res) => {
-                resolve(res ?? '');
-            },
+        // Defer to event loop to avoid blocking on large diffs
+        setImmediate(() => {
+            createTwoFilesPatch(path.basename(params.filePath), path.basename(params.filePath), params.originalContent, params.updatedContent, 'Original', 'Modified', {
+                callback: (res) => {
+                    resolve(res ?? '');
+                },
+            });
         });
     });
     if (summary.diff.length + patch.length <=
@@ -298,7 +306,7 @@ function createReplacementMatcher(args) {
     }
     return new LiteralReplacementMatcher(args.searchPattern, args.caseSensitive);
 }
-export async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
+async function handleSearchAndReplace(args, signal, onProgress = () => { }) {
     const maxFileSize = MAX_TEXT_FILE_SIZE;
     const root = await resolveSearchRoot(args.path, signal);
     const matcher = createReplacementMatcher(args);
@@ -315,7 +323,22 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
         suppressErrors: true,
     });
     const summary = createReplaceSummary(root);
-    const { stoppedByLimit } = await processEntriesConcurrently(entries, {
+    const timerStartName = `searchAndReplaceStart_${Date.now()}`;
+    const timerEndName = `searchAndReplaceEnd_${Date.now()}`;
+    const metricName = `searchAndReplace_${Date.now()}`;
+    performance.mark(timerStartName);
+    const context = {
+        options: {
+            dryRun: args.dryRun,
+            returnDiff: args.returnDiff ?? false,
+        },
+        replacement: args.replacement,
+        matcher,
+        maxFileSize,
+        signal,
+        summary,
+    };
+    const { stoppedByLimit } = await replaceContextStorage.run(context, () => processEntriesConcurrently(entries, {
         signal,
         concurrency: REPLACE_CONCURRENCY,
         ...(args.maxFiles !== undefined ? { maxEntries: args.maxFiles } : {}),
@@ -325,18 +348,15 @@ export async function handleSearchAndReplace(args, signal, onProgress = () => {
                 throttleModulo: 25,
             });
         },
-        runEntry: async (entryPath) => processEntry(entryPath, {
-            options: {
-                dryRun: args.dryRun,
-                returnDiff: args.returnDiff ?? false,
-            },
-            replacement: args.replacement,
-            matcher,
-            maxFileSize,
-            signal,
-            summary,
-        }),
-    });
+        runEntry: processEntry,
+    }));
+    performance.mark(timerEndName);
+    performance.measure(metricName, timerStartName, timerEndName);
+    const durationMs = performance.getEntriesByName(metricName)[0]?.duration ?? 0;
+    performance.clearMarks(timerStartName);
+    performance.clearMarks(timerEndName);
+    performance.clearMeasures(metricName);
+    summary.perfTimeMs = durationMs;
     if (stoppedByLimit) {
         summary.stoppedReason = 'maxFiles';
     }
@@ -354,13 +374,14 @@ export function registerSearchAndReplaceTool(server, options = {}) {
         ...(args.path ? { context: { path: args.path } } : {}),
         run: async (signal) => {
             const dryLabel = args.dryRun ? ' [dry run]' : '';
-            const context = `"${args.searchPattern}" in ${args.filePattern}${dryLabel}`;
+            const truncatedPattern = truncateProgressPattern(args.searchPattern);
+            const context = `"${truncatedPattern}" in ${args.filePattern}${dryLabel}`;
             const progress = createToolProgressSession(extra, `🛠 replace: ${context}`);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🛠 replace: ${args.searchPattern} [${current} files]`,
+                    message: `🛠 replace: ${truncatedPattern} [${current} files]`,
                 });
             };
             try {
@@ -394,7 +415,10 @@ export function registerSearchAndReplaceTool(server, options = {}) {
 function buildSearchAndReplaceText(summary, dryRun) {
     const failureSuffix = summary.failedFiles > 0 ? ` (${summary.failedFiles} failed)` : '';
     const dryRunSuffix = dryRun ? ' (Dry run)' : '';
-    return `Found ${summary.totalMatches} matches in ${summary.filesChanged} files${failureSuffix}.${dryRunSuffix}`;
+    const timing = summary.perfTimeMs
+        ? ` [\u23F1\uFE0F ${summary.perfTimeMs.toFixed(0)}ms]`
+        : '';
+    return `Found ${summary.totalMatches} matches in ${summary.filesChanged} files${failureSuffix}.${dryRunSuffix}${timing}`;
 }
 function buildSearchAndReplaceStructuredResult(summary, args) {
     return {

package/dist/tools/search-content.js

@@ -1,11 +1,12 @@
 import * as path from 'node:path';
+import { performance } from 'node:perf_hooks';
 import RE2 from 're2';
 import { DEFAULT_EXCLUDE_PATTERNS } from '../lib/constants.js';
 import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
 import { searchContent } from '../lib/file-operations/search.js';
 import { formatOperationSummary } from '../config.js';
 import { SearchContentInputSchema, SearchContentOutputSchema, } from '../schemas.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 /**
  * Configuration constants for the Search Content tool.
@@ -18,6 +19,7 @@ const CONFIG = {
         maxFiles: 'max files',
     },
 };
+let searchMetricSequence = 0;
 const TRUTHY_SUMMARY_FIELDS = [
     'filesMatched',
     'skippedTooLarge',
@@ -26,15 +28,20 @@ const TRUTHY_SUMMARY_FIELDS = [
     'linesSkippedDueToRegexTimeout',
 ];
 function buildStructuredSummaryFields(summary) {
-    const truthyFields = Object.fromEntries(TRUTHY_SUMMARY_FIELDS.flatMap((key) => {
+    const result = {};
+    for (const key of TRUTHY_SUMMARY_FIELDS) {
         const value = summary[key];
-        return value ? [[key, value]] : [];
-    }));
-    return {
-        ...truthyFields,
-        ...(summary.truncated ? { truncated: true } : {}),
-        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
-    };
+        if (value) {
+            result[key] = value;
+        }
+    }
+    if (summary.truncated) {
+        result.truncated = true;
+    }
+    if (summary.stoppedReason) {
+        result.stoppedReason = summary.stoppedReason;
+    }
+    return result;
 }
 function buildCompletionSuffix(count, filesMatched, scope, stoppedReason) {
     if (count === 0)
@@ -46,6 +53,15 @@ function buildCompletionSuffix(count, filesMatched, scope, stoppedReason) {
         : '';
     return `${count} ${matchWord} in ${filesMatched} ${fileWord}${reasonSuffix}`;
 }
+function createSearchMetricNames() {
+    searchMetricSequence += 1;
+    const metricSuffix = `${Date.now()}_${searchMetricSequence}`;
+    return {
+        timerStartName: `searchContentStart_${metricSuffix}`,
+        timerEndName: `searchContentEnd_${metricSuffix}`,
+        metricName: `searchContent_${metricSuffix}`,
+    };
+}
 function compareNormalizedMatches(left, right) {
     const fileCompare = left.relativeFile.localeCompare(right.relativeFile);
     if (fileCompare !== 0)
@@ -159,30 +175,11 @@ const SearchResponseBuilder = {
     buildMatchList(heading, matches) {
         if (matches.length === 0)
             return heading;
-        // Fast path: calculate exact byte length to avoid arrays and string concatenation in V8
-        // +1 for newline after heading. Each match gets: "  " (2) + relativeFile + ":" + line + ": " (2) + content + "\n"
-        let totalBytes = Buffer.byteLength(heading, 'utf8');
+        const parts = [heading];
         for (const match of matches) {
-            totalBytes +=
-                1 + // \n
-                    2 + // "  "
-                    Buffer.byteLength(match.relativeFile, 'utf8') +
-                    1 + // ":"
-                    Math.max(4, String(match.line).length) +
-                    2 + // ": "
-                    Buffer.byteLength(match.content, 'utf8');
+            parts.push(`\n  ${match.relativeFile}:${String(match.line).padStart(4)}: ${match.content}`);
         }
-        const buf = Buffer.allocUnsafe(totalBytes);
-        let offset = buf.write(heading, 0, 'utf8');
-        for (const match of matches) {
-            offset += buf.write('\n  ', offset, 'utf8');
-            offset += buf.write(match.relativeFile, offset, 'utf8');
-            offset += buf.write(':', offset, 'utf8');
-            offset += buf.write(String(match.line).padStart(4), offset, 'utf8');
-            offset += buf.write(': ', offset, 'utf8');
-            offset += buf.write(match.content, offset, 'utf8');
-        }
-        return buf.toString('utf8', 0, offset);
+        return parts.join('');
     },
     resolveTruncatedReason(summary) {
         if (summary.stoppedReason === 'timeout')
@@ -215,6 +212,7 @@ const SearchResponseBuilder = {
 const SearchExecutor = {
     async run(args, basePath, signal, onProgress) {
         const excludePatterns = args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS;
+        const { timerStartName, timerEndName, metricName } = createSearchMetricNames();
         const options = {
             includeHidden: args.includeHidden,
             excludePatterns,
@@ -228,6 +226,7 @@ const SearchExecutor = {
             ...(signal ? { signal } : {}),
             ...(onProgress ? { onProgress } : {}),
         };
+        performance.mark(timerStartName);
         try {
             return await searchContent(basePath, args.pattern, options);
         }
@@ -237,6 +236,13 @@ const SearchExecutor = {
             }
             throw error;
         }
+        finally {
+            performance.mark(timerEndName);
+            performance.measure(metricName, timerStartName, timerEndName);
+            performance.clearMarks(timerStartName);
+            performance.clearMarks(timerEndName);
+            performance.clearMeasures(metricName);
+        }
     },
     createMatcher(args) {
         if (!args.isRegex)
@@ -303,7 +309,7 @@ export function registerSearchContentTool(server, options = {}) {
         context: { path: args.path ?? '.' },
         run: async (signal) => {
             const { pattern, filePattern: scope } = args;
-            const progressLabel = `🔎︎ grep: ${pattern}`;
+            const progressLabel = `🔎︎ grep: ${truncateProgressPattern(pattern)}`;
             const progress = createToolProgressSession(extra, progressLabel);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({

package/dist/tools/search-files.js

@@ -4,7 +4,7 @@ import { ErrorCode } from '../lib/errors.js';
 import { searchFiles } from '../lib/file-operations/search.js';
 import { formatOperationSummary, joinLines } from '../config.js';
 import { SearchFilesInputSchema, SearchFilesOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createProgressReporter, decodeOffsetCursor, encodeOffsetCursor, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, createProgressReporter, decodeOffsetCursor, encodeOffsetCursor, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, truncateProgressPattern, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 export const SEARCH_FILES_TOOL = {
     name: 'find',
@@ -109,11 +109,12 @@ export function registerSearchFilesTool(server, options = {}) {
             const rawScopeLabel = args.path ? path.basename(args.path) : '.';
             const scopeLabel = rawScopeLabel || '.';
             const { pattern } = args;
-            const context = `${pattern} in ${scopeLabel}`;
+            const truncatedPattern = truncateProgressPattern(pattern);
+            const context = `${truncatedPattern} in ${scopeLabel}`;
             let progressCursor = 0;
             notifyProgress(extra, {
                 current: 0,
-                message: `🔎︎ find: ${pattern}`,
+                message: `🔎︎ find: ${truncatedPattern}`,
             });
             const baseReporter = createProgressReporter(extra);
             const progressWithMessage = ({ current, total, }) => {
@@ -122,7 +123,7 @@ export function registerSearchFilesTool(server, options = {}) {
                 baseReporter({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🔎︎ find: ${pattern} [${current} files]`,
+                    message: `🔎︎ find: ${truncatedPattern} [${current} files]`,
                 });
             };
             try {

package/dist/tools/shared.d.ts

@@ -22,7 +22,6 @@ export declare const IDEMPOTENT_WRITE_TOOL_ANNOTATIONS: {
     readonly destructiveHint: false;
     readonly openWorldHint: false;
 };
-export declare function shouldStripStructuredOutput(): boolean;
 export declare function maybeStripStructuredContentFromResult<T extends object>(result: T): T;
 type ResourceEntry = ReturnType<ResourceStore['putText']>;
 export declare function maybeExternalizeTextContent(resourceStore: ResourceStore | undefined, content: string, params: {
@@ -114,7 +113,7 @@ export declare function notifyProgress(extra: ToolExtra, progress: {
     total?: number;
     message?: string;
 }): void;
-export interface ToolProgressSession {
+interface ToolProgressSession {
     update: (progress: {
         current: number;
         total?: number;
@@ -125,7 +124,7 @@ export interface ToolProgressSession {
     fail: (message: string, minimumCurrent?: number) => void;
     getCurrent: () => number;
 }
-export interface BatchProgressCallbacks {
+interface BatchProgressCallbacks {
     progress: ToolProgressSession;
     onItemComplete: () => void;
 }
@@ -155,6 +154,7 @@ export declare function resolvePathOrRoot(pathValue: string | undefined): string
 export declare function encodeOffsetCursor(offset: number): string;
 export declare function decodeOffsetCursor(cursor: string): number;
 export declare function buildBatchPathContext(paths: readonly string[], unitLabel?: string): string;
+export declare function truncateProgressPattern(pattern: string, maxLength?: number): string;
 export declare function buildBatchCompletionSuffix(summary: {
     total?: number;
     failed?: number;

package/dist/tools/shared.js

@@ -64,7 +64,7 @@ function normalizeToolExecution(tool) {
     }
     return normalized;
 }
-export function shouldStripStructuredOutput() {
+function shouldStripStructuredOutput() {
     return parseTrueEnvFlag(process.env['FS_CONTEXT_STRIP_STRUCTURED']);
 }
 export function maybeStripStructuredContentFromResult(result) {
@@ -488,6 +488,20 @@ export function buildBatchPathContext(paths, unitLabel = 'paths') {
         : '';
     return `${paths.length} ${normalizedLabel} [${first}${extraPaths}]`;
 }
+export function truncateProgressPattern(pattern, maxLength = 40) {
+    if (pattern.length <= maxLength)
+        return pattern;
+    if (pattern.includes('|')) {
+        const segments = pattern.split('|');
+        const first = segments[0] ?? '';
+        const second = segments[1];
+        const preview = second !== undefined ? `${first}|${second}` : first;
+        return preview.length <= maxLength
+            ? `${preview}…`
+            : `${preview.slice(0, maxLength)}…`;
+    }
+    return `${pattern.slice(0, maxLength)}…`;
+}
 export function buildBatchCompletionSuffix(summary, successWord, singularWord) {
     const total = summary?.total ?? 0;
     const failed = summary?.failed ?? 0;

package/dist/tools/task-support.d.ts

@@ -1,15 +1,8 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 import type { ToolTaskHandler } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { AnySchema, SchemaOutput, ShapeOutput, ZodRawShapeCompat } from '@modelcontextprotocol/sdk/server/zod-compat.js';
 import type { RequestTaskStore } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import type { IconInfo, ToolExtra, ToolResult } from './shared.js';
-export interface TaskContext {
-    taskId: string;
-    toolName?: string | undefined;
-    startTime: number;
-}
-export declare const taskContext: AsyncLocalStorage<TaskContext>;
 type TaskToolExtra = ToolExtra & {
     taskId?: string;
     taskStore?: RequestTaskStore;

package/dist/tools/task-support.js

@@ -7,13 +7,16 @@ import { DEFAULT_TASK_TTL_MS, MAX_CONCURRENT_TASKS, MAX_TASK_TTL_MS, } from '../
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { isRecord } from '../lib/utils.js';
 import { buildToolErrorResponse, maybeStripStructuredContentFromResult, withDefaultIcons, } from './shared.js';
-export const taskContext = new AsyncLocalStorage();
+const taskContext = new AsyncLocalStorage();
 const TASK_DIAGNOSTICS_CHANNEL = channel('filesystem-mcp:tasks');
 function publishTaskDiagnostics(event) {
     if (TASK_DIAGNOSTICS_CHANNEL.hasSubscribers) {
         TASK_DIAGNOSTICS_CHANNEL.publish(event);
     }
 }
+function getDynamicProperty(target, key) {
+    return Reflect.get(target, key);
+}
 // --- Type Guards & Helpers ---
 function isExperimentalTaskRegistration(value) {
     if (!isRecord(value))
@@ -22,8 +25,7 @@ function isExperimentalTaskRegistration(value) {
     return (registerToolTask === undefined || typeof registerToolTask === 'function');
 }
 function getExperimentalTaskRegistration(server) {
-    const serverWithExperimental = server;
-    const { experimental } = serverWithExperimental;
+    const experimental = getDynamicProperty(server, 'experimental');
     if (!isRecord(experimental))
         return undefined;
     const { tasks } = experimental;
@@ -32,11 +34,10 @@ function getExperimentalTaskRegistration(server) {
     return tasks;
 }
 function hasTaskToolCapability(server) {
-    const serverRecord = server;
-    const { server: serverRuntime } = serverRecord;
+    const serverRuntime = getDynamicProperty(server, 'server');
     if (!isRecord(serverRuntime))
         return true; // Assume capability if runtime structure is opaque
-    const { getCapabilities } = serverRuntime;
+    const getCapabilities = getDynamicProperty(serverRuntime, 'getCapabilities');
     if (typeof getCapabilities !== 'function')
         return true;
     const capabilities = getCapabilities.call(serverRuntime);

package/dist/tools.d.ts

@@ -1,6 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type ToolContract } from './tools/contract.js';
 import type { ToolRegistrationOptions } from './tools/shared.js';
-export { buildToolErrorResponse, buildToolResponse } from './tools/shared.js';
 export declare const ALL_TOOLS: ToolContract[];
 export declare function registerAllTools(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools.js

@@ -17,7 +17,6 @@ import { GET_MULTIPLE_FILE_INFO_TOOL, registerGetMultipleFileInfoTool, } from '.
 import { GET_FILE_INFO_TOOL, registerGetFileInfoTool } from './tools/stat.js';
 import { registerTreeTool, TREE_TOOL } from './tools/tree.js';
 import { registerWriteFileTool, WRITE_FILE_TOOL } from './tools/write-file.js';
-export { buildToolErrorResponse, buildToolResponse } from './tools/shared.js';
 const TOOL_ENTRIES = [
     {
         contract: LIST_ALLOWED_DIRECTORIES_TOOL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.13.0",
+  "version": "1.13.2",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "A local filesystem MCP server that lets LLMs and AI agents read, write, search, diff, patch, and manage files safely and efficiently. Built for reliable, structured, and controlled filesystem interaction.",
   "type": "module",
@@ -86,17 +86,16 @@
     "@eslint/js": "^10.0.1",
     "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/node": "^24",
-    "eslint": "^10.0.2",
+    "eslint": "^10.0.3",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-de-morgan": "^2.1.1",
     "eslint-plugin-depend": "^1.5.0",
     "eslint-plugin-unused-imports": "^4.4.1",
-    "jscpd": "^4.0.8",
-    "knip": "^5.85.0",
+    "knip": "^5.86.0",
     "prettier": "^3.8.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.56.1"
+    "typescript-eslint": "^8.57.0"
   },
   "engines": {
     "node": ">=24"