@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/lib/fs-helpers.js

@@ -1,606 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { isUtf8 } from 'node:buffer';
-import { createHash, randomUUID } from 'node:crypto';
-import { createReadStream } from 'node:fs';
-import { open, rename, stat, unlink, writeFile, } from 'node:fs/promises';
-import { extname } from 'node:path';
-import { pipeline } from 'node:stream/promises';
-import { assertNotAborted, withAbort } from './abort.js';
-import { BINARY_CHECK_BUFFER_SIZE, KNOWN_BINARY_EXTENSIONS, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, } from './constants.js';
-import { ErrorCode, McpError, normalizeUnknownError } from './errors.js';
-import { assertAllowedFileAccess, validateExistingPath } from './paths.js';
-const READ_ONLY_FILE_FLAG = 'r';
-function assertPositiveSafeIntegerOption(name, value, message) {
-    if (value === undefined)
-        return;
-    if (typeof value !== 'number' ||
-        !Number.isFinite(value) ||
-        !Number.isSafeInteger(value) ||
-        value < 1) {
-        throw new McpError(ErrorCode.INVALID_INPUT, message ?? `${name} must be a positive integer`);
-    }
-}
-function normalizeConcurrency(concurrency) {
-    assertPositiveSafeIntegerOption('concurrency', concurrency);
-    return concurrency;
-}
-function createParallelAbortError() {
-    return new DOMException('Operation aborted', 'AbortError');
-}
-export async function processInParallel(items, processor, concurrency = PARALLEL_CONCURRENCY, signal) {
-    const itemCount = items.length;
-    if (itemCount === 0)
-        return { results: [], errors: [] };
-    const effectiveConcurrency = normalizeConcurrency(concurrency);
-    // Pre-allocate slots by index to guarantee input-order output.
-    const resultSlots = new Array(itemCount);
-    const errors = [];
-    if (signal?.aborted)
-        throw createParallelAbortError();
-    let nextIndex = 0;
-    const next = async () => {
-        while (nextIndex < itemCount) {
-            if (signal?.aborted)
-                throw createParallelAbortError();
-            const index = nextIndex;
-            nextIndex += 1;
-            const item = items[index];
-            try {
-                const result = await processor(item);
-                if (signal?.aborted)
-                    throw createParallelAbortError();
-                resultSlots[index] = result;
-            }
-            catch (error) {
-                if (signal?.aborted)
-                    throw createParallelAbortError();
-                errors.push({
-                    index,
-                    error: normalizeUnknownError(error),
-                });
-            }
-        }
-    };
-    const workerCount = Math.min(itemCount, effectiveConcurrency);
-    const workers = new Array(workerCount);
-    for (let index = 0; index < workerCount; index += 1) {
-        workers[index] = next();
-    }
-    await Promise.allSettled(workers);
-    if (signal?.aborted)
-        throw createParallelAbortError();
-    const results = [];
-    for (const slot of resultSlots) {
-        if (slot !== undefined) {
-            results.push(slot);
-        }
-    }
-    return { results, errors };
-}
-export function getFileType(stats) {
-    if (stats.isFile())
-        return 'file';
-    if (stats.isDirectory())
-        return 'directory';
-    if (stats.isSymbolicLink())
-        return 'symlink';
-    return 'other';
-}
-export function isHidden(name) {
-    return name.startsWith('.');
-}
-function hasKnownBinaryExtension(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    return KNOWN_BINARY_EXTENSIONS.has(ext);
-}
-async function openReadableFileHandle(filePath, signal) {
-    return withAbort(open(filePath, READ_ONLY_FILE_FLAG), signal);
-}
-async function readProbe(handle, signal) {
-    const buffer = Buffer.alloc(BINARY_CHECK_BUFFER_SIZE);
-    const { bytesRead } = await withAbort(handle.read(buffer, 0, BINARY_CHECK_BUFFER_SIZE, 0), signal);
-    if (bytesRead === 0) {
-        return Buffer.alloc(0);
-    }
-    return buffer.subarray(0, bytesRead);
-}
-function hasUtf16Bom(slice) {
-    return (slice.length >= 2 &&
-        ((slice[0] === 0xff && slice[1] === 0xfe) ||
-            (slice[0] === 0xfe && slice[1] === 0xff)));
-}
-export async function isProbablyBinary(filePath, existingHandle, signal) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        if (hasKnownBinaryExtension(filePath)) {
-            return true;
-        }
-        if (existingHandle) {
-            const slice = await readProbe(existingHandle, signal);
-            return isBinarySlice(slice);
-        }
-        const effectivePath = await validateExistingPath(filePath, signal);
-        const handle = __addDisposableResource(env_1, await openReadableFileHandle(effectivePath, signal), true);
-        const slice = await readProbe(handle, signal);
-        return isBinarySlice(slice);
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
-    }
-}
-function isBinarySlice(slice) {
-    if (slice.length === 0)
-        return false;
-    if (hasUtf16Bom(slice))
-        return false;
-    if (slice.includes(0))
-        return true;
-    return !isUtf8(slice);
-}
-export async function calculateFileContentHash(filePath, signal) {
-    const hasher = createHash('sha256');
-    await pipeline(createReadStream(filePath, { signal, highWaterMark: STREAM_CHUNK_SIZE }), hasher, { signal });
-    return hasher.digest('hex');
-}
-function validateReadOptions(options) {
-    const hasHead = options.head !== undefined;
-    const hasTail = options.tail !== undefined;
-    const hasStart = options.startLine !== undefined;
-    const hasEnd = options.endLine !== undefined;
-    assertPositiveSafeIntegerOption('maxSize', options.maxSize, 'maxSize must be at least 1');
-    assertPositiveSafeIntegerOption('head', options.head, 'head must be at least 1');
-    assertPositiveSafeIntegerOption('tail', options.tail, 'tail must be at least 1');
-    assertPositiveSafeIntegerOption('startLine', options.startLine, 'startLine must be at least 1');
-    assertPositiveSafeIntegerOption('endLine', options.endLine, 'endLine must be at least 1');
-    if (hasHead && (hasStart || hasEnd)) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'head cannot be used together with startLine/endLine');
-    }
-    if (hasTail && (hasHead || hasStart || hasEnd)) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'tail cannot be used together with head/startLine/endLine');
-    }
-    {
-        const effectiveStart = options.startLine ?? 1;
-        if (options.endLine !== undefined && options.endLine < effectiveStart) {
-            throw new McpError(ErrorCode.INVALID_INPUT, 'endLine must be greater than or equal to startLine (default: 1)');
-        }
-    }
-}
-function normalizeOptions(options) {
-    validateReadOptions(options);
-    const normalized = {
-        encoding: options.encoding ?? 'utf-8',
-        maxSize: Math.min(options.maxSize ?? MAX_TEXT_FILE_SIZE, MAX_TEXT_FILE_SIZE),
-        skipBinary: options.skipBinary ?? false,
-    };
-    if (options.head !== undefined) {
-        normalized.head = options.head;
-    }
-    if (options.tail !== undefined) {
-        normalized.tail = options.tail;
-    }
-    if (options.endLine !== undefined) {
-        normalized.startLine = options.startLine ?? 1;
-        normalized.endLine = options.endLine;
-    }
-    else if (options.startLine !== undefined) {
-        normalized.startLine = options.startLine;
-    }
-    if (options.signal) {
-        normalized.signal = options.signal;
-    }
-    return normalized;
-}
-function prepareReadOptions(options) {
-    const normalized = normalizeOptions(options);
-    assertNotAborted(normalized.signal);
-    return normalized;
-}
-function buildReadContentOptions(normalized) {
-    const readOptions = {
-        encoding: normalized.encoding,
-        maxSize: normalized.maxSize,
-    };
-    if (normalized.signal) {
-        readOptions.signal = normalized.signal;
-    }
-    return readOptions;
-}
-function resolveReadMode(options) {
-    if (options.head !== undefined)
-        return 'head';
-    if (options.tail !== undefined)
-        return 'tail';
-    if (options.startLine !== undefined || options.endLine !== undefined)
-        return 'range';
-    return 'full';
-}
-const STREAM_CHUNK_SIZE = 64 * 1024;
-function createTooLargeError(bytesRead, maxSize, requestedPath) {
-    return new McpError(ErrorCode.TOO_LARGE, `File exceeds size limit (${bytesRead} > ${maxSize} bytes)`, requestedPath, { size: bytesRead, maxSize });
-}
-async function readFileBufferWithLimit(handle, maxSize, requestedPath, signal) {
-    const stream = handle.createReadStream({
-        start: 0,
-        highWaterMark: STREAM_CHUNK_SIZE,
-        autoClose: false,
-        emitClose: false,
-        signal,
-    });
-    const chunks = [];
-    let totalSize = 0;
-    try {
-        for await (const chunk of stream) {
-            const buffer = Buffer.isBuffer(chunk)
-                ? chunk
-                : Buffer.from(chunk);
-            totalSize += buffer.length;
-            if (totalSize > maxSize) {
-                stream.destroy();
-                throw createTooLargeError(totalSize, maxSize, requestedPath);
-            }
-            chunks.push(buffer);
-        }
-    }
-    finally {
-        if (!stream.destroyed) {
-            stream.destroy();
-        }
-    }
-    return Buffer.concat(chunks, totalSize);
-}
-function countLines(content) {
-    if (content.length === 0)
-        return 0;
-    let count = 1;
-    for (let i = 0; i < content.length; i++) {
-        if (content.charCodeAt(i) === 10)
-            count++;
-    }
-    return count;
-}
-async function readHeadContent(handle, head, options) {
-    assertNotAborted(options.signal);
-    const lines = [];
-    let estimatedBytes = 0;
-    const newlineBytes = Buffer.byteLength('\n', options.encoding);
-    const iterator = handle
-        .readLines({ encoding: options.encoding, signal: options.signal })[Symbol.asyncIterator]();
-    let hasMoreLines = false;
-    let next = await iterator.next();
-    try {
-        while (!next.done) {
-            const line = next.value;
-            lines.push(line);
-            estimatedBytes +=
-                Buffer.byteLength(line, options.encoding) + newlineBytes;
-            if (estimatedBytes >= options.maxSize) {
-                hasMoreLines = true;
-                break;
-            }
-            if (lines.length === head) {
-                const peek = await iterator.next();
-                hasMoreLines = !peek.done;
-                break;
-            }
-            next = await iterator.next();
-        }
-    }
-    finally {
-        await iterator.return?.();
-    }
-    const content = lines.join('\n');
-    const linesRead = lines.length;
-    return {
-        content,
-        truncated: hasMoreLines,
-        linesRead,
-        hasMoreLines,
-    };
-}
-async function readRangeContent(handle, startLine, endLine, options) {
-    assertNotAborted(options.signal);
-    const lines = [];
-    let lineNumber = 0;
-    let estimatedBytes = 0;
-    const hasEndLine = endLine !== undefined;
-    let stoppedByLimit = false;
-    let reachedEof = false;
-    const newlineBytes = Buffer.byteLength('\n', options.encoding);
-    const iterator = handle
-        .readLines({ encoding: options.encoding, signal: options.signal })[Symbol.asyncIterator]();
-    let hasMoreLines = false;
-    const stopAt = endLine ?? Number.POSITIVE_INFINITY;
-    let stoppedEarly = false;
-    let next = await iterator.next();
-    try {
-        while (!next.done) {
-            const line = next.value;
-            lineNumber++;
-            if (lineNumber < startLine) {
-                next = await iterator.next();
-                continue;
-            }
-            if (lineNumber > stopAt) {
-                hasMoreLines = true;
-                stoppedEarly = true;
-                break;
-            }
-            lines.push(line);
-            estimatedBytes +=
-                Buffer.byteLength(line, options.encoding) + newlineBytes;
-            if (estimatedBytes >= options.maxSize) {
-                stoppedByLimit = true;
-                stoppedEarly = true;
-                break;
-            }
-            if (hasEndLine && lineNumber === stopAt) {
-                const peek = await iterator.next();
-                hasMoreLines = !peek.done;
-                reachedEof = Boolean(peek.done);
-                stoppedEarly = true;
-                break;
-            }
-            next = await iterator.next();
-        }
-    }
-    finally {
-        await iterator.return?.();
-    }
-    if (!stoppedEarly) {
-        reachedEof = true;
-    }
-    const content = lines.join('\n');
-    const linesRead = countLines(content);
-    const effectiveHasMoreLines = hasEndLine
-        ? hasMoreLines || (stoppedByLimit && !reachedEof)
-        : stoppedByLimit && !reachedEof;
-    return {
-        content,
-        truncated: stoppedByLimit || effectiveHasMoreLines,
-        linesRead,
-        hasMoreLines: effectiveHasMoreLines,
-    };
-}
-async function readTailContent(handle, tail, options) {
-    assertNotAborted(options.signal);
-    const ring = new Array(tail);
-    let totalLines = 0;
-    let head = 0;
-    let size = 0;
-    for await (const line of handle.readLines({
-        encoding: options.encoding,
-        signal: options.signal,
-    })) {
-        ring[head] = line;
-        head = (head + 1) % tail;
-        if (size < tail)
-            size++;
-        totalLines++;
-    }
-    const lines = new Array(size);
-    const start = size < tail ? 0 : head;
-    for (let i = 0; i < size; i++) {
-        lines[i] = ring[(start + i) % tail] ?? '';
-    }
-    const content = lines.join('\n');
-    const linesRead = countLines(content);
-    const hasMoreLines = totalLines > tail;
-    return {
-        content,
-        truncated: hasMoreLines,
-        linesRead,
-        hasMoreLines,
-    };
-}
-async function readFullContent(handle, encoding, maxSize, requestedPath, signal) {
-    const buffer = await readFileBufferWithLimit(handle, maxSize, requestedPath, signal);
-    const content = buffer.toString(encoding);
-    return { content, totalLines: countLines(content) };
-}
-async function assertNotBinary(validPath, filePath, normalized) {
-    assertNotAborted(normalized.signal);
-    const isBinary = await isProbablyBinary(validPath, undefined, normalized.signal);
-    if (!isBinary)
-        return;
-    throw new McpError(ErrorCode.INVALID_INPUT, 'Binary file detected.', filePath);
-}
-function assertSizeWithinLimit(size, maxSize, filePath) {
-    if (size <= maxSize)
-        return;
-    throw new McpError(ErrorCode.TOO_LARGE, `File too large (${size} > ${maxSize} bytes). Use head to preview.`, filePath, { size, maxSize });
-}
-function requireReadOption(normalized, key, filePath) {
-    const value = normalized[key];
-    if (value !== undefined) {
-        return value;
-    }
-    throw new McpError(ErrorCode.INVALID_INPUT, `Missing ${key} option`, filePath);
-}
-async function executeHeadRead(context) {
-    const head = requireReadOption(context.normalized, 'head', context.filePath);
-    const readOptions = buildReadContentOptions(context.normalized);
-    const { content, truncated, linesRead, hasMoreLines } = await readHeadContent(context.handle, head, readOptions);
-    return {
-        path: context.validPath,
-        content,
-        truncated,
-        readMode: 'head',
-        head,
-        linesRead,
-        hasMoreLines,
-    };
-}
-async function executeRangeRead(context) {
-    const startLine = requireReadOption(context.normalized, 'startLine', context.filePath);
-    const { endLine } = context.normalized;
-    const readOptions = buildReadContentOptions(context.normalized);
-    const { content, truncated, linesRead, hasMoreLines } = await readRangeContent(context.handle, startLine, endLine, readOptions);
-    return {
-        path: context.validPath,
-        content,
-        truncated,
-        readMode: 'range',
-        startLine,
-        ...(endLine !== undefined ? { endLine } : {}),
-        linesRead,
-        hasMoreLines,
-    };
-}
-async function executeFullRead(context) {
-    assertSizeWithinLimit(context.stats.size, context.normalized.maxSize, context.filePath);
-    const { content, totalLines } = await readFullContent(context.handle, context.normalized.encoding, context.normalized.maxSize, context.filePath, context.normalized.signal);
-    return {
-        path: context.validPath,
-        content,
-        truncated: false,
-        totalLines,
-        readMode: 'full',
-        linesRead: totalLines,
-        hasMoreLines: false,
-    };
-}
-async function executeTailRead(context) {
-    const tail = requireReadOption(context.normalized, 'tail', context.filePath);
-    const readOptions = buildReadContentOptions(context.normalized);
-    const { content, truncated, linesRead, hasMoreLines } = await readTailContent(context.handle, tail, readOptions);
-    return {
-        path: context.validPath,
-        content,
-        truncated,
-        readMode: 'tail',
-        tail,
-        linesRead,
-        hasMoreLines,
-    };
-}
-const READ_MODE_HANDLERS = {
-    head: executeHeadRead,
-    range: executeRangeRead,
-    full: executeFullRead,
-    tail: executeTailRead,
-};
-async function readByMode(context) {
-    const mode = resolveReadMode(context.normalized);
-    return READ_MODE_HANDLERS[mode](context);
-}
-function assertFileStats(filePath, stats) {
-    if (!stats.isFile()) {
-        throw new McpError(ErrorCode.NOT_FILE, 'Not a regular file', filePath);
-    }
-}
-async function readFileWithStatsInternal(filePath, validPath, stats, normalized) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
-    try {
-        assertNotAborted(normalized.signal);
-        assertAllowedFileAccess(filePath, validPath);
-        assertFileStats(filePath, stats);
-        if (normalized.skipBinary) {
-            await assertNotBinary(validPath, filePath, normalized);
-        }
-        assertNotAborted(normalized.signal);
-        const handle = __addDisposableResource(env_2, await openReadableFileHandle(validPath, normalized.signal), true);
-        return await readByMode({
-            handle,
-            validPath,
-            filePath,
-            stats,
-            normalized,
-        });
-    }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
-    }
-    finally {
-        const result_2 = __disposeResources(env_2);
-        if (result_2)
-            await result_2;
-    }
-}
-export async function readFileWithStats(filePath, validPath, stats, options = {}) {
-    const normalized = prepareReadOptions(options);
-    return readFileWithStatsInternal(filePath, validPath, stats, normalized);
-}
-export async function readFile(filePath, options = {}) {
-    const normalized = prepareReadOptions(options);
-    const validPath = await validateExistingPath(filePath, normalized.signal);
-    assertNotAborted(normalized.signal);
-    const stats = await withAbort(stat(validPath), normalized.signal);
-    return readFileWithStatsInternal(filePath, validPath, stats, normalized);
-}
-export async function atomicWriteFile(filePath, content, options = {}) {
-    const { encoding = 'utf-8', signal } = options;
-    const tempPath = `${filePath}.${randomUUID()}.tmp`;
-    try {
-        assertNotAborted(signal);
-        await writeFile(tempPath, content, { encoding, signal });
-        await withAbort(rename(tempPath, filePath), signal);
-    }
-    catch (error) {
-        // Attempt cleanup on error, but don't overwrite the original error
-        try {
-            await unlink(tempPath).catch(() => { });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-        throw error;
-    }
-}

package/dist/lib/globs.d.ts

@@ -1,2 +0,0 @@
-export declare function isSafeGlobPattern(value: string): boolean;
-export declare function assertSafeGlobPattern(value: string, message?: string): void;

package/dist/lib/globs.js

@@ -1,19 +0,0 @@
-import { ErrorCode, McpError } from './errors.js';
-const ABSOLUTE_GLOB_RE = /^([/\\]|[A-Za-z]:[/\\]|\\\\)/u;
-const PARENT_SEGMENT_RE = /[\\/]\.\.(?:[/\\]|$)/u;
-export function isSafeGlobPattern(value) {
-    if (value.length === 0)
-        return false;
-    if (value.includes('**/**/**'))
-        return false;
-    if (ABSOLUTE_GLOB_RE.test(value))
-        return false;
-    if (value.startsWith('..') || PARENT_SEGMENT_RE.test(value))
-        return false;
-    return true;
-}
-export function assertSafeGlobPattern(value, message = 'Invalid glob or unsafe path (absolute/.. forbidden)') {
-    if (!isSafeGlobPattern(value)) {
-        throw new McpError(ErrorCode.INVALID_PATTERN, message);
-    }
-}

package/dist/lib/logger.d.ts

@@ -1,27 +0,0 @@
-import type { LoggingLevel, McpServer } from '@modelcontextprotocol/server';
-import { AsyncLocalStorage } from 'node:async_hooks';
-interface SessionContextData {
-    sessionId?: string;
-}
-export declare const SessionContext: AsyncLocalStorage<SessionContextData>;
-export interface LogEvent {
-    level: LoggingLevel;
-    message: string;
-    data?: unknown;
-    sessionId?: string;
-}
-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 const Logger: {
-    emit(level: LoggingLevel, message: string, data?: unknown): void;
-    debug(message: string, data?: unknown): void;
-    info(message: string, data?: unknown): void;
-    notice(message: string, data?: unknown): void;
-    warn(message: string, data?: unknown): void;
-    error(message: string, data?: unknown): void;
-    critical(message: string, data?: unknown): void;
-};
-export {};