@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/server/roots-manager.js

@@ -1,227 +0,0 @@
-import {} from '@modelcontextprotocol/server';
-import { channel } from 'node:diagnostics_channel';
-import { realpath } from 'node:fs/promises';
-import { z } from 'zod';
-import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/abort.js';
-import { getInitHandshakeTimeoutMs } from '../lib/constants.js';
-import { formatUnknownErrorMessage } from '../lib/errors.js';
-import { Logger, logToMcp } from '../lib/logger.js';
-import { getValidRootDirectories, isPathWithinDirectories, normalizePath, resolveAllowedDirectoriesState, setAllowedDirectoriesStateResolved, } from '../lib/paths.js';
-import { debounce, isRecord } from '../lib/utils.js';
-const ROOTS_TIMEOUT_MS = 5000;
-const ROOTS_DEBOUNCE_MS = 100;
-const LIFECYCLE_CHANNEL = channel('filesystem-mcp:lifecycle');
-function normalizeCLIDirectories(dirs) {
-    const normalized = [];
-    for (const dir of dirs) {
-        const trimmed = dir.trim();
-        if (trimmed.length === 0)
-            continue;
-        normalized.push(normalizePath(trimmed));
-    }
-    return normalized;
-}
-const RootSchema = z.strictObject({
-    uri: z.string(),
-    name: z.string().optional(),
-});
-const RootsResponseSchema = z.strictObject({
-    roots: z.array(RootSchema).optional(),
-});
-function isRoot(value) {
-    return isRecord(value) && typeof value['uri'] === 'string';
-}
-function normalizeRoot(root) {
-    return root.name ? { uri: root.uri, name: root.name } : { uri: root.uri };
-}
-function extractRoots(value) {
-    const parsed = RootsResponseSchema.safeParse(value);
-    if (!parsed.success || !parsed.data.roots) {
-        return [];
-    }
-    const roots = [];
-    for (const root of parsed.data.roots) {
-        if (isRoot(root)) {
-            roots.push(normalizeRoot(root));
-        }
-    }
-    return roots;
-}
-async function resolveRootDirectories(roots) {
-    if (roots.length === 0)
-        return [];
-    const { signal, cleanup } = createTimedAbortSignal(undefined, ROOTS_TIMEOUT_MS);
-    try {
-        return await getValidRootDirectories(roots, signal);
-    }
-    finally {
-        cleanup();
-    }
-}
-async function isRootWithinBaseline(normalizedRoot, baseline, signal) {
-    if (!isPathWithinDirectories(normalizedRoot, baseline)) {
-        return false;
-    }
-    try {
-        assertNotAborted(signal);
-        const realPath = await withAbort(realpath(normalizedRoot), signal);
-        const normalizedReal = normalizePath(realPath);
-        return isPathWithinDirectories(normalizedReal, baseline);
-    }
-    catch {
-        return false;
-    }
-}
-async function filterRootsWithinBaseline(roots, baseline, signal) {
-    const normalizedBaseline = normalizeCLIDirectories(baseline);
-    const normalizedRoots = roots.map(normalizePath);
-    if (normalizedRoots.length === 0)
-        return [];
-    const results = await Promise.allSettled(normalizedRoots.map((normalizedRoot) => isRootWithinBaseline(normalizedRoot, normalizedBaseline, signal)));
-    return normalizedRoots.filter((_, i) => {
-        const result = results[i];
-        return result?.status === 'fulfilled' && result.value;
-    });
-}
-export class RootsManager {
-    _debouncedUpdate;
-    rootDirectories = [];
-    allowedDirectoriesState = {
-        primary: [],
-        expanded: [],
-    };
-    clientInitialized = false;
-    initTimer;
-    // Guard concurrent root refreshes; if one is already running we queue one
-    // replay so the last-known state still gets applied after completion.
-    updatingRoots = false;
-    // Tracks whether a roots change arrived while the previous refresh ran.
-    pendingRootsUpdate = false;
-    options;
-    loggingState;
-    constructor(options, loggingState) {
-        this.options = options;
-        this.loggingState = loggingState;
-    }
-    isInitialized() {
-        return this.clientInitialized;
-    }
-    destroy() {
-        if (this.initTimer) {
-            clearTimeout(this.initTimer);
-            this.initTimer = undefined;
-        }
-        if (this._debouncedUpdate) {
-            this._debouncedUpdate.cancel();
-            this._debouncedUpdate = undefined;
-        }
-    }
-    getAllowedDirectoriesState() {
-        return {
-            primary: [...this.allowedDirectoriesState.primary],
-            expanded: [...this.allowedDirectoriesState.expanded],
-        };
-    }
-    logMissingDirectoriesIfNeeded(server) {
-        if (this.allowedDirectoriesState.expanded.length === 0) {
-            this.logMissingDirectories(server);
-        }
-    }
-    registerHandlers(server, onInitTimeout) {
-        const initHandshakeTimeoutMs = getInitHandshakeTimeoutMs();
-        server.server.setNotificationHandler('notifications/initialized', async () => {
-            if (this.initTimer) {
-                clearTimeout(this.initTimer);
-                this.initTimer = undefined;
-            }
-            this.clientInitialized = true;
-            await this.updateRootsFromClient(server);
-        });
-        server.server.setNotificationHandler('notifications/roots/list_changed', () => {
-            if (!this.clientInitialized)
-                return;
-            this.scheduleRootsUpdate(server);
-        });
-        this.initTimer = setTimeout(() => {
-            if (!this.clientInitialized) {
-                if (LIFECYCLE_CHANNEL.hasSubscribers) {
-                    LIFECYCLE_CHANNEL.publish({
-                        phase: 'init_timeout',
-                        timeoutMs: initHandshakeTimeoutMs,
-                    });
-                }
-                logToMcp(server, 'warning', `Client did not send notifications/initialized within ${String(initHandshakeTimeoutMs)}ms`, this.loggingState.minimumLevel);
-                onInitTimeout?.();
-            }
-            this.initTimer = undefined;
-        }, initHandshakeTimeoutMs);
-        this.initTimer.unref();
-    }
-    async recomputeAllowedDirectories() {
-        const cliAllowedDirs = normalizeCLIDirectories(this.options.cliAllowedDirs ?? []);
-        const allowCwd = Boolean(this.options.allowCwd);
-        const allowCwdDirs = allowCwd ? [normalizePath(process.cwd())] : [];
-        const baseline = [...cliAllowedDirs, ...allowCwdDirs];
-        const { signal, cleanup } = createTimedAbortSignal(undefined, ROOTS_TIMEOUT_MS);
-        try {
-            const rootsToInclude = baseline.length > 0
-                ? await filterRootsWithinBaseline(this.rootDirectories, baseline, signal)
-                : this.rootDirectories;
-            const combined = [...baseline, ...rootsToInclude];
-            const nextState = await resolveAllowedDirectoriesState(combined, signal);
-            this.allowedDirectoriesState = nextState;
-            setAllowedDirectoriesStateResolved(nextState);
-        }
-        finally {
-            cleanup();
-        }
-    }
-    scheduleRootsUpdate(server) {
-        this._debouncedUpdate ??= debounce((s) => {
-            void this.updateRootsFromClient(s);
-        }, ROOTS_DEBOUNCE_MS);
-        this._debouncedUpdate(server);
-    }
-    logMissingDirectories(server) {
-        if (this.options.allowCwd) {
-            logToMcp(server, 'notice', 'No allowed directories specified. Using the current working directory as an allowed directory.', this.loggingState.minimumLevel);
-            return;
-        }
-        logToMcp(server, 'warning', 'No allowed directories specified. Please provide directories as command-line arguments or enable --allow-cwd to use the current working directory.', this.loggingState.minimumLevel);
-    }
-    async updateRootsFromClient(server) {
-        // Guard against concurrent executions: if one is already running, queue a
-        // single retry so the last-known state is always applied after completion.
-        if (this.updatingRoots) {
-            this.pendingRootsUpdate = true;
-            return;
-        }
-        this.updatingRoots = true;
-        try {
-            const clientCapabilities = server.server.getClientCapabilities();
-            if (!clientCapabilities?.roots) {
-                this.rootDirectories = [];
-            }
-            else {
-                const rootsResult = await server.server.listRoots(undefined, {
-                    timeout: ROOTS_TIMEOUT_MS,
-                });
-                const roots = extractRoots(rootsResult);
-                this.rootDirectories = await resolveRootDirectories(roots);
-            }
-        }
-        catch (error) {
-            logToMcp(server, 'debug', `[DEBUG] MCP Roots protocol unavailable or failed: ${formatUnknownErrorMessage(error)}`, this.loggingState.minimumLevel);
-        }
-        finally {
-            await this.recomputeAllowedDirectories();
-            Logger.info(`Roots updated: ${this.rootDirectories.length} root(s), ${this.allowedDirectoriesState.expanded.length} allowed dir(s)`);
-            this.updatingRoots = false;
-            // If a change arrived while we were running, apply it now.
-            if (this.pendingRootsUpdate) {
-                this.pendingRootsUpdate = false;
-                void this.updateRootsFromClient(server);
-            }
-        }
-    }
-}

package/dist/server/task-store.d.ts

@@ -1,10 +0,0 @@
-import { InMemoryTaskStore, type Result, type Task } from '@modelcontextprotocol/server';
-export declare class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
-    private readonly cancelledResults;
-    private evictExpired;
-    getTaskResult(taskId: string, sessionId?: string): Promise<Result>;
-    storeTaskResult(taskId: string, status: 'completed' | 'failed', result: Result, sessionId?: string): Promise<void>;
-    updateTaskStatus(taskId: string, status: Task['status'], statusMessage?: string, sessionId?: string): Promise<void>;
-    cleanup(): void;
-}
-export declare function createTaskStore(): ResultAwareInMemoryTaskStore;

package/dist/server/task-store.js

@@ -1,91 +0,0 @@
-import { InMemoryTaskStore, } from '@modelcontextprotocol/server';
-import { CANCELLED_RESULT_TTL_MS } from '../lib/constants.js';
-import { ErrorCode } from '../lib/errors.js';
-const DEFAULT_CANCELLED_STATUS_MESSAGE = 'Client cancelled task execution.';
-function getTaskKey(taskId, sessionId) {
-    return `${sessionId ?? ''}:${taskId}`;
-}
-function buildCancelledTaskResult(statusMessage) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `Error [${ErrorCode.CANCELLED}]: ${statusMessage ?? DEFAULT_CANCELLED_STATUS_MESSAGE}`,
-            },
-        ],
-        isError: true,
-        errorCode: ErrorCode.CANCELLED,
-    };
-}
-export class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
-    cancelledResults = new Map();
-    evictExpired() {
-        const now = Date.now();
-        for (const [key, entry] of this.cancelledResults) {
-            if (now - entry.createdAt > CANCELLED_RESULT_TTL_MS) {
-                this.cancelledResults.delete(key);
-            }
-        }
-    }
-    async getTaskResult(taskId, sessionId) {
-        this.evictExpired();
-        try {
-            return await super.getTaskResult(taskId, sessionId);
-        }
-        catch (error) {
-            const task = await super.getTask(taskId, sessionId);
-            if (task?.status !== 'cancelled') {
-                throw error;
-            }
-            const key = getTaskKey(taskId, sessionId);
-            const existing = this.cancelledResults.get(key);
-            if (existing)
-                return existing.result;
-            const result = buildCancelledTaskResult(task.statusMessage);
-            this.cancelledResults.set(key, { result, createdAt: Date.now() });
-            return result;
-        }
-    }
-    async storeTaskResult(taskId, status, result, sessionId) {
-        try {
-            await super.storeTaskResult(taskId, status, result, sessionId);
-            if (status !== 'failed') {
-                this.cancelledResults.delete(getTaskKey(taskId, sessionId));
-            }
-        }
-        catch (error) {
-            const task = await super.getTask(taskId, sessionId);
-            if (task?.status !== 'cancelled') {
-                throw error;
-            }
-            const key = getTaskKey(taskId, sessionId);
-            const existing = this.cancelledResults.get(key);
-            this.cancelledResults.set(key, {
-                result: existing?.result ?? result,
-                createdAt: existing?.createdAt ?? Date.now(),
-            });
-        }
-    }
-    async updateTaskStatus(taskId, status, statusMessage, sessionId) {
-        await super.updateTaskStatus(taskId, status, statusMessage, sessionId);
-        const key = getTaskKey(taskId, sessionId);
-        if (status === 'cancelled') {
-            const existing = this.cancelledResults.get(key);
-            this.cancelledResults.set(key, {
-                result: existing?.result ?? buildCancelledTaskResult(statusMessage),
-                createdAt: existing?.createdAt ?? Date.now(),
-            });
-            return;
-        }
-        if (status === 'completed' || status === 'failed') {
-            this.cancelledResults.delete(key);
-        }
-    }
-    cleanup() {
-        this.cancelledResults.clear();
-        super.cleanup();
-    }
-}
-export function createTaskStore() {
-    return new ResultAwareInMemoryTaskStore();
-}

package/dist/tools/apply-patch.d.ts

@@ -1,4 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
-export declare const APPLY_PATCH_TOOL: ToolContract;
-export declare function registerApplyPatchTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/apply-patch.js

@@ -1,235 +0,0 @@
-import { stat } from 'node:fs/promises';
-import { basename, resolve } from 'node:path';
-import { applyPatch, parsePatch } from 'diff';
-import { withAbort } from '../lib/abort.js';
-import { MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY } from '../lib/constants.js';
-import { ErrorCode, McpError } from '../lib/errors.js';
-import { atomicWriteFile, processInParallel, readFileWithStats, } from '../lib/fs-helpers.js';
-import { Logger } from '../lib/logger.js';
-import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
-import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
-import { FILE_EDIT_ICONS } from './icons.js';
-import { buildStructuredError, buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const APPLY_PATCH_TOOL = {
-    name: 'apply_patch',
-    title: 'Apply Patch',
-    description: 'Apply a unified diff patch to one or more files. ' +
-        'Single-file: throws on failure. Multi-file: best-effort per file with `results[]`. ' +
-        '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,
-    icons: FILE_EDIT_ICONS,
-    nuances: [
-        'Multi-file patches use `path` as base directory; per-file results in `results[]`.',
-    ],
-    taskSupport: 'optional',
-};
-function assertPatchTargetSizeWithinLimit(filePath, size, maxFileSize) {
-    if (size <= maxFileSize)
-        return;
-    throw new McpError(ErrorCode.TOO_LARGE, `File too large for patch (${size} bytes > ${maxFileSize} bytes).`, filePath, { size, maxFileSize });
-}
-function countStructuredPatchStats(diff) {
-    let linesAdded = 0;
-    let linesRemoved = 0;
-    for (const hunk of diff.hunks) {
-        for (const line of hunk.lines) {
-            if (line.startsWith('+'))
-                linesAdded++;
-            else if (line.startsWith('-'))
-                linesRemoved++;
-        }
-    }
-    return { hunksApplied: diff.hunks.length, linesAdded, linesRemoved };
-}
-function stripGitPrefix(fileName) {
-    return fileName.startsWith('a/') || fileName.startsWith('b/')
-        ? fileName.slice(2)
-        : fileName;
-}
-function extractPatchTargetPath(diff) {
-    if (diff.newFileName)
-        return stripGitPrefix(diff.newFileName);
-    if (diff.oldFileName)
-        return stripGitPrefix(diff.oldFileName);
-    return undefined;
-}
-async function applyDiff(filePath, diff, options, signal) {
-    const validPath = await validateExistingPath(filePath, signal);
-    assertAllowedFileAccess(filePath, validPath);
-    const stats = await withAbort(stat(validPath), signal);
-    assertPatchTargetSizeWithinLimit(validPath, stats.size, MAX_TEXT_FILE_SIZE);
-    const { content } = await readFileWithStats(filePath, validPath, stats, {
-        encoding: 'utf-8',
-        maxSize: MAX_TEXT_FILE_SIZE,
-        skipBinary: true,
-        ...(signal ? { signal } : {}),
-    });
-    const patched = applyPatch(content, diff, {
-        fuzzFactor: options.fuzzFactor,
-        autoConvertLineEndings: options.autoConvertLineEndings,
-    });
-    if (patched === false) {
-        return {
-            path: validPath,
-            applied: false,
-            error: buildStructuredError(new McpError(ErrorCode.INVALID_INPUT, 'Patch application failed', validPath), ErrorCode.INVALID_INPUT, validPath),
-        };
-    }
-    if (patched === content) {
-        return {
-            path: validPath,
-            applied: false,
-            error: buildStructuredError(new McpError(ErrorCode.INVALID_INPUT, 'Patch had no effect', validPath), ErrorCode.INVALID_INPUT, validPath),
-        };
-    }
-    const patchStats = countStructuredPatchStats(diff);
-    if (!options.dryRun) {
-        await atomicWriteFile(validPath, patched, { encoding: 'utf-8', signal });
-    }
-    return { path: validPath, applied: true, ...patchStats };
-}
-async function processMultiFilePatch(basePath, parsed, options, signal) {
-    const validBase = await validateExistingPath(basePath, signal);
-    const promises = parsed.map((diff) => {
-        const fileName = extractPatchTargetPath(diff);
-        if (!fileName) {
-            return () => Promise.resolve({
-                path: '<unknown>',
-                applied: false,
-                error: buildStructuredError(new McpError(ErrorCode.INVALID_INPUT, 'Missing file name in patch header'), ErrorCode.INVALID_INPUT),
-            });
-        }
-        const filePath = resolve(validBase, fileName);
-        return async () => {
-            try {
-                const result = await applyDiff(filePath, diff, options, signal);
-                return { ...result, path: fileName };
-            }
-            catch (error) {
-                return {
-                    path: fileName,
-                    applied: false,
-                    error: buildStructuredError(error, ErrorCode.INVALID_INPUT, filePath),
-                };
-            }
-        };
-    });
-    const { results } = await processInParallel(promises, (task) => task(), PARALLEL_CONCURRENCY, signal);
-    const totals = results.reduce((acc, r) => {
-        if (r.applied) {
-            acc.applied++;
-            acc.hunks += r.hunksApplied ?? 0;
-            acc.added += r.linesAdded ?? 0;
-            acc.removed += r.linesRemoved ?? 0;
-        }
-        return acc;
-    }, { applied: 0, hunks: 0, added: 0, removed: 0 });
-    const label = options.dryRun ? ' (dry run)' : '';
-    if (totals.applied === 0) {
-        const failedPaths = results
-            .filter((r) => !r.applied)
-            .map((r) => r.path)
-            .join(', ');
-        throw new McpError(ErrorCode.INVALID_INPUT, `All ${parsed.length} patches failed${label}. Files: ${failedPaths}. Regenerate via diff_files.`);
-    }
-    const text = `Applied ${totals.applied}/${parsed.length} file patches${label}`;
-    if (!options.dryRun) {
-        Logger.info(`apply_patch: ${basePath} (${totals.applied} file(s), +${totals.added}/-${totals.removed})`);
-    }
-    return buildToolResponse(text, {
-        ok: totals.applied === parsed.length,
-        path: basePath,
-        applied: totals.applied > 0,
-        hunksApplied: totals.hunks,
-        linesAdded: totals.added,
-        linesRemoved: totals.removed,
-        results,
-    });
-}
-async function handleApplyPatch(args, signal) {
-    if (!args.patch.trim()) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Patch content is empty.');
-    }
-    const fuzzFactor = args.fuzzFactor ?? 0;
-    const parsed = parsePatch(args.patch);
-    const hasHunks = parsed.some((p) => p.hunks.length > 0);
-    if (!hasHunks) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Patch must include unified hunk headers (@@ -n,n +n,n @@).');
-    }
-    const options = {
-        dryRun: args.dryRun,
-        fuzzFactor,
-        autoConvertLineEndings: args.autoConvertLineEndings,
-    };
-    if (parsed.length > 1) {
-        return processMultiFilePatch(args.path, parsed, options, signal);
-    }
-    const diff = parsed[0];
-    if (!diff) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'No patch content found.');
-    }
-    const result = await applyDiff(args.path, diff, options, signal);
-    if (!result.applied) {
-        throw new McpError(ErrorCode.INVALID_INPUT, result.error?.message === 'Patch had no effect'
-            ? 'Patch had no effect. Content unchanged. Regenerate via diff_files.'
-            : 'Patch failed. Content may have changed. Regenerate via diff_files. For minor diffs, use fuzzFactor.');
-    }
-    const text = args.dryRun
-        ? 'Dry run successful. Patch can be applied.'
-        : `Successfully patched ${args.path}`;
-    if (!args.dryRun) {
-        Logger.info(`apply_patch: ${args.path} (+${result.linesAdded ?? 0}/-${result.linesRemoved ?? 0})`);
-    }
-    return buildToolResponse(text, {
-        ok: true,
-        path: result.path,
-        applied: true,
-        hunksApplied: result.hunksApplied,
-        linesAdded: result.linesAdded,
-        linesRemoved: result.linesRemoved,
-    });
-}
-export function registerApplyPatchTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: 'apply_patch',
-        ctx,
-        outputSchema: ApplyPatchOutputSchema,
-        timedSignal: {},
-        context: { path: args.path },
-        run: async (signal) => {
-            const result = await handleApplyPatch(args, signal);
-            if (!args.dryRun) {
-                const sc = result.structuredContent;
-                void ctx.log?.('info', `patch: ${args.path} (+${String(sc.linesAdded ?? 0)}/-${String(sc.linesRemoved ?? 0)})`);
-            }
-            return result;
-        },
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
-    });
-    registerStandardTool(server, APPLY_PATCH_TOOL, handler, options, {
-        progressMessage: (args) => {
-            const name = basename(args.path);
-            return args.dryRun
-                ? `${APPLY_PATCH_TOOL.title}: ${name} [dry run]`
-                : `${APPLY_PATCH_TOOL.title}: ${name}`;
-        },
-        completionMessage: (args, result) => {
-            const name = basename(args.path);
-            if (result.isError)
-                return `${APPLY_PATCH_TOOL.title}: ${name} • ${result.errorCode}`;
-            const sc = result.structuredContent;
-            if (!sc.ok)
-                return `${APPLY_PATCH_TOOL.title}: ${name} • failed`;
-            const added = sc.linesAdded ?? 0;
-            const removed = sc.linesRemoved ?? 0;
-            const dry = args.dryRun ? 'dry run ' : '';
-            if (added > 0 || removed > 0)
-                return `${APPLY_PATCH_TOOL.title}: ${name} • ${dry} +${added} -${removed}`;
-            return `${APPLY_PATCH_TOOL.title}: ${name} • ${dry}no changes`;
-        },
-    });
-}

package/dist/tools/calculate-hash.d.ts

@@ -1,4 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/server';
-import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
-export declare const CALCULATE_HASH_TOOL: ToolContract;
-export declare function registerCalculateHashTool(server: McpServer, options?: ToolRegistrationOptions): void;