@j0hanz/filesystem-mcp 1.19.1 → 2.0.0

package/dist/tools/edit-file.js

@@ -1,256 +0,0 @@
-import { stat } from 'node:fs/promises';
-import { basename } from 'node:path';
-import { createTwoFilesPatch, diffLines } from 'diff';
-import RE2 from 're2';
-import { withAbort } from '../lib/abort.js';
-import { MAX_TEXT_FILE_SIZE } from '../lib/constants.js';
-import { ErrorCode, McpError } from '../lib/errors.js';
-import { atomicWriteFile, readFileWithStats } from '../lib/fs-helpers.js';
-import { Logger } from '../lib/logger.js';
-import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
-import { EditFileInputSchema, EditFileOutputSchema } from '../schemas.js';
-import { FILE_EDIT_ICONS } from './icons.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const EDIT_FILE_TOOL = {
-    name: 'edit',
-    title: 'Edit File',
-    description: 'Apply sequential literal string replacements to a file (first occurrence per edit). ' +
-        '`oldText` must match exactly — include 3–5 lines of context for unique targeting. ' +
-        'Use `dryRun:true` to preview.',
-    inputSchema: EditFileInputSchema,
-    outputSchema: EditFileOutputSchema,
-    annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
-    icons: FILE_EDIT_ICONS,
-    nuances: ['Each edit applies to the output of the previous edit.'],
-    taskSupport: 'forbidden',
-};
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function getLineNumberAtIndex(str, maxIndex = str.length) {
-    let count = 1;
-    let pos = 0;
-    while (pos < maxIndex) {
-        pos = str.indexOf('\n', pos);
-        if (pos === -1 || pos >= maxIndex)
-            break;
-        count++;
-        pos++;
-    }
-    return count;
-}
-function countLines(str) {
-    return getLineNumberAtIndex(str);
-}
-async function computeDiffStats(original, modified) {
-    return new Promise((resolve) => {
-        diffLines(original, modified, {
-            callback: (changes) => {
-                let linesAdded = 0;
-                let linesRemoved = 0;
-                for (const part of changes) {
-                    if (part.added) {
-                        linesAdded += part.count;
-                    }
-                    else if (part.removed) {
-                        linesRemoved += part.count;
-                    }
-                }
-                resolve({ linesAdded, linesRemoved });
-            },
-        });
-    });
-}
-function findEditMatch(content, oldText, ignoreWhitespace, regexCache) {
-    if (ignoreWhitespace) {
-        const pattern = escapeRegExp(oldText).replace(/\s+/g, '\\s+');
-        let regex = regexCache?.get(pattern);
-        if (!regex) {
-            regex = new RE2(pattern);
-            if (regexCache)
-                regexCache.set(pattern, regex);
-        }
-        const match = regex.exec(content);
-        if (!match) {
-            return undefined;
-        }
-        return {
-            startIndex: match.index,
-            length: match[0].length,
-        };
-    }
-    const index = content.indexOf(oldText);
-    if (index === -1) {
-        return undefined;
-    }
-    return {
-        startIndex: index,
-        length: oldText.length,
-    };
-}
-function replaceEditMatch(content, match, newText) {
-    return (content.slice(0, match.startIndex) +
-        newText +
-        content.slice(match.startIndex + match.length));
-}
-function mergeLineRange(currentRange, content, matchStartIndex, newText) {
-    const startLine = getLineNumberAtIndex(content, matchStartIndex);
-    const endLine = startLine + countLines(newText) - 1;
-    if (!currentRange) {
-        return [startLine, endLine];
-    }
-    return [
-        Math.min(currentRange[0], startLine),
-        Math.max(currentRange[1], endLine),
-    ];
-}
-function buildStructuredEditOutput(validPath, result) {
-    return {
-        ok: result.appliedEdits > 0 || result.unmatchedEdits.length === 0,
-        path: validPath,
-        appliedEdits: result.appliedEdits,
-        ...(result.appliedEdits > 0
-            ? {
-                linesAdded: result.linesAdded,
-                linesRemoved: result.linesRemoved,
-            }
-            : {}),
-        ...(result.unmatchedEdits.length > 0
-            ? { unmatchedEdits: result.unmatchedEdits }
-            : {}),
-        ...(result.lineRange ? { lineRange: result.lineRange } : {}),
-    };
-}
-async function finalizeEditResult(originalContent, updatedContent, appliedEdits, unmatchedEdits, lineRange) {
-    const { linesAdded, linesRemoved } = appliedEdits > 0
-        ? await computeDiffStats(originalContent, updatedContent)
-        : { linesAdded: 0, linesRemoved: 0 };
-    return {
-        content: updatedContent,
-        appliedEdits,
-        unmatchedEdits,
-        linesAdded,
-        linesRemoved,
-        ...(lineRange ? { lineRange } : {}),
-    };
-}
-async function buildDiff(validPath, original, modified) {
-    const fileName = basename(validPath);
-    return new Promise((resolve) => {
-        createTwoFilesPatch(fileName, fileName, original, modified, 'Original', 'Modified', {
-            callback: (res) => {
-                resolve(res ?? '');
-            },
-        });
-    });
-}
-function formatUnmatchedEditsNote(unmatchedEdits) {
-    if (unmatchedEdits.length === 0) {
-        return '';
-    }
-    return ` — ${unmatchedEdits.length} unmatched: [${unmatchedEdits
-        .map((text) => JSON.stringify(text.length > 40 ? `${text.slice(0, 40)}…` : text))
-        .join(', ')}]`;
-}
-function buildEditMessage(requestedPath, result) {
-    const unmatchedNote = formatUnmatchedEditsNote(result.unmatchedEdits);
-    if (result.appliedEdits === 0) {
-        return `No edits applied to ${requestedPath}${unmatchedNote}`;
-    }
-    return `Successfully applied ${result.appliedEdits} edits to ${requestedPath}${unmatchedNote}`;
-}
-async function loadEditableFile(requestedPath, signal) {
-    const validPath = await validateExistingPath(requestedPath, signal);
-    assertAllowedFileAccess(requestedPath, validPath);
-    const stats = await withAbort(stat(validPath), signal);
-    if (stats.size > MAX_TEXT_FILE_SIZE) {
-        throw new McpError(ErrorCode.TOO_LARGE, `File too large for edit (${stats.size} bytes > ${MAX_TEXT_FILE_SIZE} bytes)`, requestedPath, { size: stats.size, maxFileSize: MAX_TEXT_FILE_SIZE });
-    }
-    const { content } = await readFileWithStats(requestedPath, validPath, stats, {
-        encoding: 'utf-8',
-        maxSize: MAX_TEXT_FILE_SIZE,
-        skipBinary: true,
-        ...(signal ? { signal } : {}),
-    });
-    return { validPath, content };
-}
-function buildEditProgressMessage(args) {
-    const name = basename(args.path);
-    const tag = args.dryRun ? ' [dry run]' : '';
-    return `${EDIT_FILE_TOOL.title}: ${name}${tag}`;
-}
-function buildEditCompletionMessage(args, result) {
-    const name = basename(args.path);
-    if (result.isError)
-        return `${EDIT_FILE_TOOL.title}: ${name} • ${result.errorCode}`;
-    const { structuredContent } = result;
-    if (!structuredContent.ok)
-        return `${EDIT_FILE_TOOL.title}: ${name} • failed`;
-    const applied = structuredContent.appliedEdits ?? 0;
-    if (applied === 0)
-        return `${EDIT_FILE_TOOL.title}: ${name} • no changes`;
-    const added = structuredContent.linesAdded ?? 0;
-    const removed = structuredContent.linesRemoved ?? 0;
-    const dry = args.dryRun ? 'dry run ' : '';
-    return `${EDIT_FILE_TOOL.title}: ${name} • ${dry} +${added} -${removed}`;
-}
-async function applyEdits(content, edits, ignoreWhitespace) {
-    let newContent = content;
-    let appliedEdits = 0;
-    const unmatchedEdits = [];
-    let lineRange;
-    const regexCache = ignoreWhitespace ? new Map() : undefined;
-    for (const edit of edits) {
-        const match = findEditMatch(newContent, edit.oldText, ignoreWhitespace, regexCache);
-        if (!match) {
-            unmatchedEdits.push(edit.oldText);
-            continue;
-        }
-        lineRange = mergeLineRange(lineRange, newContent, match.startIndex, edit.newText);
-        newContent = replaceEditMatch(newContent, match, edit.newText);
-        appliedEdits += 1;
-    }
-    return finalizeEditResult(content, newContent, appliedEdits, unmatchedEdits, lineRange);
-}
-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);
-    if (args.dryRun) {
-        if (editResult.appliedEdits > 0) {
-            structured.diff = await buildDiff(validPath, content, editResult.content);
-        }
-        return buildToolResponse(`Dry run complete. ${editResult.appliedEdits} edits would be applied.`, structured);
-    }
-    if (editResult.appliedEdits === 0 && editResult.unmatchedEdits.length > 0) {
-        throw new McpError(ErrorCode.INVALID_INPUT, `All ${editResult.unmatchedEdits.length} edits failed. Verify oldText matches exact file content.`, args.path);
-    }
-    if (editResult.appliedEdits > 0) {
-        await atomicWriteFile(validPath, editResult.content, {
-            encoding: 'utf-8',
-            signal,
-        });
-        Logger.info(`edit: ${args.path} (${editResult.appliedEdits} edits, +${editResult.linesAdded}/-${editResult.linesRemoved})`);
-    }
-    return buildToolResponse(buildEditMessage(args.path, editResult), structured);
-}
-export function registerEditFileTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: 'edit',
-        ctx,
-        outputSchema: EditFileOutputSchema,
-        timedSignal: {},
-        context: { path: args.path },
-        run: async (signal) => {
-            const result = await handleEditFile(args, signal);
-            void ctx.log?.('info', `edit: ${args.path} (${String(result.structuredContent.appliedEdits ?? 0)} edits)`);
-            return result;
-        },
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
-    });
-    registerStandardTool(server, EDIT_FILE_TOOL, handler, options, {
-        progressMessage: buildEditProgressMessage,
-        completionMessage: buildEditCompletionMessage,
-    });
-}

package/dist/tools/icons.d.ts

@@ -1,15 +0,0 @@
-import type { Icon } from '@modelcontextprotocol/server';
-/** Document with lines — read, read_many, stat, stat_many, calculate_hash, diff_files */
-export declare const FILE_READ_ICONS: Icon[];
-/** Folder — ls, tree, find, roots */
-export declare const DIRECTORY_ICONS: Icon[];
-/** Magnifying glass — grep */
-export declare const SEARCH_ICONS: Icon[];
-/** Pencil — write, edit, apply_patch, search_and_replace */
-export declare const FILE_EDIT_ICONS: Icon[];
-/** Arrow — mv */
-export declare const FILE_MOVE_ICONS: Icon[];
-/** Trash — rm */
-export declare const FILE_DELETE_ICONS: Icon[];
-/** Folder with plus — mkdir */
-export declare const DIR_CREATE_ICONS: Icon[];

package/dist/tools/icons.js

@@ -1,24 +0,0 @@
-const MIME = 'image/svg+xml';
-function svgIcon(paths) {
-    const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">${paths}</svg>`;
-    return [
-        {
-            src: `data:${MIME};base64,${Buffer.from(svg).toString('base64')}`,
-            mimeType: MIME,
-        },
-    ];
-}
-/** Document with lines — read, read_many, stat, stat_many, calculate_hash, diff_files */
-export const FILE_READ_ICONS = svgIcon('<path d="M4 1h5l4 4v9a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V2a1 1 0 0 1 1-1z"/><path d="M9 1v4h4"/><path d="M6 8h4M6 11h3"/>');
-/** Folder — ls, tree, find, roots */
-export const DIRECTORY_ICONS = svgIcon('<path d="M2 4h4l2 2h6v7a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1z"/>');
-/** Magnifying glass — grep */
-export const SEARCH_ICONS = svgIcon('<circle cx="6.5" cy="6.5" r="4"/><path d="M10 10l4 4"/>');
-/** Pencil — write, edit, apply_patch, search_and_replace */
-export const FILE_EDIT_ICONS = svgIcon('<path d="M11 2l3 3-9 9H2v-3z"/>');
-/** Arrow — mv */
-export const FILE_MOVE_ICONS = svgIcon('<path d="M2 8h12M10 4l4 4-4 4"/>');
-/** Trash — rm */
-export const FILE_DELETE_ICONS = svgIcon('<path d="M3 4h10M5.5 4V3h5v1"/><path d="M4 4l.7 9.5h6.6L12 4"/>');
-/** Folder with plus — mkdir */
-export const DIR_CREATE_ICONS = svgIcon('<path d="M2 4h4l2 2h6v7a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1z"/><path d="M8 9v3M6.5 10.5h3"/>');

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

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

package/dist/tools/list-directory.js

@@ -1,218 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { basename } from 'node:path';
-import { z } from 'zod';
-import { DEFAULT_EXCLUDE_PATTERNS, MAX_LIST_ENTRIES, } from '../lib/constants.js';
-import { ErrorCode, McpError } from '../lib/errors.js';
-import { listDirectory } from '../lib/file-operations/metadata.js';
-import { createBase64JsonCodec } from '../lib/zod-codecs.js';
-import { formatOperationSummary, joinLines } from '../config.js';
-import { ListDirectoryInputSchema, ListDirectoryOutputSchema, } from '../schemas.js';
-import { DIRECTORY_ICONS } from './icons.js';
-import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const LIST_DIRECTORY_TOOL = {
-    name: 'ls',
-    title: 'List Directory',
-    description: 'List immediate directory contents (non-recursive): name, path, type, size, modified date. ' +
-        'Omit path for workspace root. `includeIgnored=true` for node_modules etc. ' +
-        'For recursive search, use `find`.',
-    inputSchema: ListDirectoryInputSchema,
-    outputSchema: ListDirectoryOutputSchema,
-    annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    icons: DIRECTORY_ICONS,
-    taskSupport: 'optional',
-    nuances: ['`pattern` enables filtered recursive traversal up to `maxDepth`.'],
-};
-const LIST_CURSOR_TTL_MS = parseInt(process.env['FS_CONTEXT_LIST_CURSOR_TTL_MS'] ?? '', 10) ||
-    5 * 60 * 1000;
-const listSnapshots = new Map();
-const listSnapshotTimers = new Map();
-const ListCursorPayloadSchema = z.strictObject({
-    snapshotId: z.string().min(1),
-    offset: z.int().min(0),
-});
-const ListCursorCodec = createBase64JsonCodec(ListCursorPayloadSchema);
-function buildListFingerprint(args) {
-    return JSON.stringify({
-        path: resolvePathOrRoot(args.path),
-        includeHidden: args.includeHidden,
-        includeIgnored: args.includeIgnored,
-        maxDepth: args.maxDepth,
-        sortBy: args.sortBy,
-        pattern: args.pattern,
-        includeSymlinkTargets: args.includeSymlinkTargets,
-    });
-}
-function deleteListSnapshot(snapshotId) {
-    listSnapshots.delete(snapshotId);
-    const timer = listSnapshotTimers.get(snapshotId);
-    if (timer) {
-        clearTimeout(timer);
-        listSnapshotTimers.delete(snapshotId);
-    }
-}
-function storeListSnapshot(snapshot) {
-    const snapshotId = randomUUID();
-    listSnapshots.set(snapshotId, snapshot);
-    const timer = setTimeout(() => {
-        deleteListSnapshot(snapshotId);
-    }, LIST_CURSOR_TTL_MS);
-    if (typeof timer.unref === 'function') {
-        timer.unref();
-    }
-    listSnapshotTimers.set(snapshotId, timer);
-    return snapshotId;
-}
-function encodeListCursor(payload) {
-    return z.encode(ListCursorCodec, payload);
-}
-function decodeListCursor(cursor) {
-    try {
-        return ListCursorCodec.parse(cursor);
-    }
-    catch {
-        // fall through to throw
-    }
-    throw new McpError(ErrorCode.INVALID_INPUT, 'Invalid or expired cursor.');
-}
-function resolveNextListCursor(snapshotId, offset, pageSize, totalEntries) {
-    if (!snapshotId)
-        return undefined;
-    const nextOffset = offset + pageSize;
-    if (nextOffset >= totalEntries) {
-        deleteListSnapshot(snapshotId);
-        return undefined;
-    }
-    return encodeListCursor({ snapshotId, offset: nextOffset });
-}
-function buildListTextResult(result, nextCursor) {
-    const { entries, summary, path } = result;
-    if (entries.length === 0) {
-        if (!summary.entriesScanned || summary.entriesScanned === 0) {
-            return `${path} (empty)`;
-        }
-        return `${path} (no matches)`;
-    }
-    const lines = [path];
-    for (const entry of entries) {
-        const suffix = entry.type === 'directory' ? '/' : '';
-        lines.push(`  ${entry.relativePath}${suffix}`);
-    }
-    let truncatedReason;
-    if (summary.truncated) {
-        if (summary.stoppedReason === 'maxEntries') {
-            truncatedReason = `max entries (${summary.totalEntries})`;
-        }
-        else {
-            truncatedReason = 'aborted';
-        }
-    }
-    const summaryOptions = {
-        truncated: summary.truncated,
-        ...(truncatedReason ? { truncatedReason } : {}),
-    };
-    let text = joinLines(lines) + formatOperationSummary(summaryOptions);
-    if (nextCursor) {
-        text += `\n[Next page available. Use cursor: "${nextCursor}"]`;
-    }
-    return text;
-}
-function buildStructuredListEntry(entry) {
-    return {
-        name: entry.name,
-        relativePath: entry.relativePath,
-        type: entry.type,
-        size: entry.size,
-        modified: entry.modified?.toISOString(),
-    };
-}
-function buildStructuredListResult(result, nextCursor) {
-    const { entries, summary, path: resultPath } = result;
-    const structuredEntries = [];
-    for (const entry of entries) {
-        structuredEntries.push(buildStructuredListEntry(entry));
-    }
-    return {
-        ok: true,
-        path: resultPath,
-        entries: structuredEntries,
-        totalEntries: summary.totalEntries,
-        ...(summary.truncated ? { truncated: summary.truncated } : {}),
-        totalFiles: summary.totalFiles,
-        totalDirectories: summary.totalDirectories,
-        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
-        ...(summary.skippedInaccessible
-            ? { skippedInaccessible: summary.skippedInaccessible }
-            : {}),
-        ...(nextCursor !== undefined ? { nextCursor } : {}),
-    };
-}
-async function handleListDirectory(args, signal) {
-    const dirPath = resolvePathOrRoot(args.path);
-    const pageSize = args.maxEntries;
-    const options = {
-        includeHidden: args.includeHidden,
-        excludePatterns: args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS,
-        sortBy: args.sortBy,
-        includeSymlinkTargets: args.includeSymlinkTargets,
-        ...(args.maxDepth !== undefined ? { maxDepth: args.maxDepth } : {}),
-        maxEntries: MAX_LIST_ENTRIES,
-        ...(args.pattern !== undefined ? { pattern: args.pattern } : {}),
-        ...(signal ? { signal } : {}),
-    };
-    const fingerprint = buildListFingerprint(args);
-    let result;
-    let cursorOffset = 0;
-    let snapshotId;
-    if (args.cursor) {
-        const cursor = decodeListCursor(args.cursor);
-        const snapshot = listSnapshots.get(cursor.snapshotId);
-        if (snapshot?.fingerprint !== fingerprint) {
-            throw new McpError(ErrorCode.INVALID_INPUT, 'Invalid or expired cursor.');
-        }
-        const { offset, snapshotId: storedSnapshotId } = cursor;
-        cursorOffset = offset;
-        snapshotId = storedSnapshotId;
-        result = {
-            path: snapshot.path,
-            entries: snapshot.entries,
-            summary: snapshot.summary,
-        };
-    }
-    else {
-        result = await listDirectory(dirPath, options);
-    }
-    const displayEntries = result.entries.slice(cursorOffset, cursorOffset + pageSize);
-    if (!args.cursor && displayEntries.length < result.entries.length) {
-        snapshotId = storeListSnapshot({
-            path: result.path,
-            entries: result.entries,
-            summary: result.summary,
-            fingerprint,
-        });
-    }
-    const nextCursor = resolveNextListCursor(snapshotId, cursorOffset, displayEntries.length, result.entries.length);
-    const displayResult = { ...result, entries: displayEntries };
-    return buildToolResponse(buildListTextResult(displayResult, nextCursor), buildStructuredListResult(displayResult, nextCursor));
-}
-export function registerListDirectoryTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: 'ls',
-        ctx,
-        outputSchema: ListDirectoryOutputSchema,
-        context: { path: args.path ?? '.' },
-        run: (signal) => handleListDirectory(args, signal),
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_DIRECTORY, args.path ?? '.'),
-    });
-    registerStandardTool(server, LIST_DIRECTORY_TOOL, handler, options, {
-        progressMessage: (args) => `${LIST_DIRECTORY_TOOL.title}: ${args.path ? basename(args.path) : '.'}`,
-        completionMessage: (args, result) => {
-            const base = args.path ? basename(args.path) : '.';
-            if (result.isError)
-                return `${LIST_DIRECTORY_TOOL.title}: ${base} • ${result.errorCode}`;
-            const sc = result.structuredContent;
-            const count = sc.totalEntries ?? 0;
-            return `${LIST_DIRECTORY_TOOL.title}: ${base} • ${count} ${count === 1 ? 'entry' : 'entries'}`;
-        },
-    });
-}

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

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