@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/config.js

@@ -1,31 +0,0 @@
-export const ErrorCode = {
-    ACCESS_DENIED: 'ACCESS_DENIED',
-    NOT_FOUND: 'NOT_FOUND',
-    NOT_FILE: 'NOT_FILE',
-    NOT_DIRECTORY: 'NOT_DIRECTORY',
-    TOO_LARGE: 'TOO_LARGE',
-    TIMEOUT: 'TIMEOUT',
-    CANCELLED: 'CANCELLED',
-    INVALID_PATTERN: 'INVALID_PATTERN',
-    INVALID_INPUT: 'INVALID_INPUT',
-    PERMISSION_DENIED: 'PERMISSION_DENIED',
-    SYMLINK_NOT_ALLOWED: 'SYMLINK_NOT_ALLOWED',
-    UNKNOWN: 'UNKNOWN',
-};
-const BYTE_UNIT_LABELS = ['B', 'KB', 'MB', 'GB', 'TB'];
-export function formatBytes(bytes) {
-    if (bytes === 0)
-        return '0 B';
-    const unitIndex = Math.floor(Math.log(bytes) / Math.log(1024));
-    const unit = BYTE_UNIT_LABELS[unitIndex] ?? 'B';
-    const value = bytes / 1024 ** unitIndex;
-    return `${parseFloat(value.toFixed(2))} ${unit}`;
-}
-export function joinLines(lines) {
-    return lines.join('\n');
-}
-export function formatOperationSummary(summary) {
-    if (!summary.truncated)
-        return '';
-    return `\n[truncated: ${summary.truncatedReason ?? 'limit reached'}]`;
-}

package/dist/lib/abort.d.ts

@@ -1,7 +0,0 @@
-export declare function assertNotAborted(signal?: AbortSignal, message?: string): void;
-export declare function withAbort<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T>;
-export declare function createTimedAbortSignal(baseSignal: AbortSignal | undefined, timeoutMs?: number): {
-    signal: AbortSignal;
-    cleanup: () => void;
-};
-export declare function withTimedAbortSignal<T>(baseSignal: AbortSignal | undefined, timeoutMs: number | undefined, run: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/lib/abort.js

@@ -1,81 +0,0 @@
-import { normalizeUnknownError } from './errors.js';
-function createAbortError(message = 'Operation aborted') {
-    return new DOMException(message, 'AbortError');
-}
-const SHARED_NOOP_SIGNAL = new AbortController().signal;
-function normalizeAbortReason(reason, message) {
-    if (reason instanceof Error)
-        return reason;
-    return createAbortError(message);
-}
-function isFiniteNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value);
-}
-export function assertNotAborted(signal, message) {
-    if (!signal)
-        return;
-    try {
-        signal.throwIfAborted();
-    }
-    catch (reason) {
-        throw normalizeAbortReason(reason, message);
-    }
-}
-function getAbortError(signal, message) {
-    try {
-        signal.throwIfAborted();
-    }
-    catch (reason) {
-        return normalizeAbortReason(reason, message);
-    }
-    return createAbortError(message);
-}
-export function withAbort(promise, signal) {
-    if (!signal)
-        return promise;
-    signal.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        const onAbort = () => {
-            reject(getAbortError(signal));
-        };
-        if (signal.aborted) {
-            onAbort();
-            return;
-        }
-        signal.addEventListener('abort', onAbort, { once: true });
-        promise.then((value) => {
-            signal.removeEventListener('abort', onAbort);
-            resolve(value);
-        }, (error) => {
-            signal.removeEventListener('abort', onAbort);
-            reject(normalizeUnknownError(error));
-        });
-    });
-}
-export function createTimedAbortSignal(baseSignal, timeoutMs) {
-    const timeoutSignal = isFiniteNumber(timeoutMs)
-        ? AbortSignal.timeout(timeoutMs)
-        : undefined;
-    if (baseSignal && timeoutSignal) {
-        return {
-            signal: AbortSignal.any([baseSignal, timeoutSignal]),
-            cleanup: () => { },
-        };
-    }
-    if (baseSignal) {
-        return { signal: baseSignal, cleanup: () => { } };
-    }
-    if (timeoutSignal) {
-        return { signal: timeoutSignal, cleanup: () => { } };
-    }
-    return { signal: SHARED_NOOP_SIGNAL, cleanup: () => { } };
-}
-export async function withTimedAbortSignal(baseSignal, timeoutMs, run) {
-    const { signal, cleanup } = createTimedAbortSignal(baseSignal, timeoutMs);
-    try {
-        return await run(signal);
-    }
-    finally {
-        cleanup();
-    }
-}

package/dist/lib/constants.d.ts

@@ -1,42 +0,0 @@
-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: "error" | "debug" | "info" | "notice" | "warning" | "critical" | "alert" | "emergency";
-export declare const DEFAULT_TASK_TTL_MS: number;
-export declare const MAX_TASK_TTL_MS: number;
-export declare const MAX_CONCURRENT_TASKS: number;
-export declare const TASK_CANCEL_POLL_MS = 2000;
-export declare function getInitHandshakeTimeoutMs(): number;
-export declare const INIT_TIMEOUT_CLOSE: boolean;
-export declare const TASK_POLL_INTERVAL_MS = 500;
-/** How long cancelled-task results are retained before lazy eviction. */
-export declare const CANCELLED_RESULT_TTL_MS: number;
-export declare const PARALLEL_CONCURRENCY: number;
-export declare const MAX_SEARCHABLE_FILE_SIZE: number;
-export declare const MAX_TEXT_FILE_SIZE: number;
-export declare const DEFAULT_READ_MANY_MAX_TOTAL_SIZE: number;
-export declare const DEFAULT_SEARCH_TIMEOUT_MS: number;
-/**
- * Number of search worker threads to use.
- * Default: CPU cores (capped at 8 for optimal I/O performance).
- * Configurable via FS_CONTEXT_SEARCH_WORKERS env var.
- */
-export declare const SEARCH_WORKERS: number;
-export declare const DEFAULT_MAX_DEPTH = 10;
-export declare const DEFAULT_LIST_MAX_ENTRIES = 20000;
-export declare const DEFAULT_SEARCH_MAX_FILES = 20000;
-export declare const MAX_TREE_DEPTH = 50;
-export declare const DEFAULT_TREE_DEPTH = 5;
-export declare const MAX_TREE_ENTRIES = 20000;
-export declare const DEFAULT_TREE_ENTRIES = 1000;
-export declare const MAX_LIST_ENTRIES = 20000;
-export declare const MAX_SEARCH_RESULTS = 10000;
-export declare const DEFAULT_SEARCH_RESULTS = 100;
-export declare const MAX_SEARCH_DEPTH = 100;
-export declare const DEFAULT_SEARCH_CONTENT_RESULTS = 500;
-export declare const MAX_LINE_CONTENT_LENGTH = 200;
-export declare const BINARY_CHECK_BUFFER_SIZE = 512;
-export declare const SENSITIVE_FILE_DENYLIST: string[];
-export declare const SENSITIVE_FILE_ALLOWLIST: string[];
-export declare const KNOWN_BINARY_EXTENSIONS: Set<string>;
-export declare const DEFAULT_EXCLUDE_PATTERNS: string[];
-export declare function getMimeType(ext: string): string;

package/dist/lib/constants.js

@@ -1,313 +0,0 @@
-import { availableParallelism } from 'node:os';
-import { Logger } from './logger.js';
-const TRUE_ENV_VALUES = new Set(['1', 'true', 'yes', 'y', 'on']);
-const FALSE_ENV_VALUES = new Set(['0', 'false', 'no', 'n', 'off']);
-export function parseTrueEnvFlag(value) {
-    if (value === undefined)
-        return false;
-    return TRUE_ENV_VALUES.has(value.trim().toLowerCase());
-}
-const KIB = 1024;
-const MIB = 1024 * KIB;
-function logInvalidEnvValue(envVar, value, expected, defaultValue) {
-    Logger.warn(`Invalid ${envVar} value: ${value} (must be ${expected}). Using default: ${String(defaultValue)}`);
-}
-// Helper for parsing environment variables (only used for configurable values)
-export function parseEnvInt(envVar, defaultValue, min, max) {
-    const value = process.env[envVar];
-    if (!value)
-        return defaultValue;
-    const parsed = parseInt(value, 10);
-    if (Number.isNaN(parsed) || parsed < min || parsed > max) {
-        logInvalidEnvValue(envVar, value, `${String(min)}-${String(max)}`, defaultValue);
-        return defaultValue;
-    }
-    return parsed;
-}
-function parseEnvBool(envVar, defaultValue) {
-    const value = process.env[envVar];
-    if (value === undefined)
-        return defaultValue;
-    const normalized = value.trim().toLowerCase();
-    if (TRUE_ENV_VALUES.has(normalized))
-        return true;
-    if (FALSE_ENV_VALUES.has(normalized))
-        return false;
-    logInvalidEnvValue(envVar, value, 'true/false', defaultValue);
-    return defaultValue;
-}
-function parseEnvList(envVar) {
-    const value = process.env[envVar];
-    if (!value)
-        return [];
-    const entries = [];
-    for (const token of value.split(/[,\n]/u)) {
-        const trimmed = token.trim();
-        if (trimmed.length > 0) {
-            entries.push(trimmed);
-        }
-    }
-    return entries;
-}
-const VALID_LOG_LEVELS = [
-    'debug',
-    'info',
-    'notice',
-    'warning',
-    'error',
-    'critical',
-    'alert',
-    'emergency',
-];
-function parseEnvLogLevel(envVar, defaultValue) {
-    const value = process.env[envVar];
-    if (!value)
-        return defaultValue;
-    const normalized = value.trim().toLowerCase();
-    if (VALID_LOG_LEVELS.includes(normalized)) {
-        return normalized;
-    }
-    Logger.warn(`Invalid ${envVar} value: ${value} (must be ${VALID_LOG_LEVELS.join('|')}). Using default: ${defaultValue}`);
-    return defaultValue;
-}
-export const DEFAULT_LOG_LEVEL = parseEnvLogLevel('FILESYSTEM_MCP_LOG_LEVEL', 'info');
-// 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);
-export const MAX_CONCURRENT_TASKS = parseEnvInt('FILESYSTEM_MCP_MAX_CONCURRENT_TASKS', 100, 1, 10_000);
-export const TASK_CANCEL_POLL_MS = 2_000;
-export function getInitHandshakeTimeoutMs() {
-    return parseEnvInt('FS_INIT_HANDSHAKE_TIMEOUT_MS', 30_000, 1_000, 300_000);
-}
-export const INIT_TIMEOUT_CLOSE = parseTrueEnvFlag(process.env['FS_INIT_TIMEOUT_CLOSE']);
-export const TASK_POLL_INTERVAL_MS = 500;
-/** How long cancelled-task results are retained before lazy eviction. */
-export const CANCELLED_RESULT_TTL_MS = 2 * 60 * 1_000; // 2 minutes
-// Auto-tuned parallelism based on CPU cores (no env override)
-const BYTES_PER_PARALLEL_TASK = 64 * MIB;
-const BYTES_PER_SEARCH_WORKER = 128 * MIB;
-function getAvailableMemory() {
-    if (typeof process.availableMemory !== 'function')
-        return undefined;
-    const available = process.availableMemory();
-    if (!Number.isFinite(available) || available <= 0)
-        return undefined;
-    return available;
-}
-function applyMemoryBound(cpuBound, bytesPerUnit, minValue) {
-    const availableMemory = getAvailableMemory();
-    if (availableMemory === undefined)
-        return cpuBound;
-    const memoryBound = Math.floor(availableMemory / bytesPerUnit);
-    return Math.min(cpuBound, Math.max(memoryBound, minValue));
-}
-function getOptimalParallelism() {
-    const cpuBound = Math.min(Math.max(availableParallelism(), 4), 32);
-    return applyMemoryBound(cpuBound, BYTES_PER_PARALLEL_TASK, 2);
-}
-function getDefaultSearchWorkers() {
-    const cpuBound = Math.min(availableParallelism(), 8);
-    return applyMemoryBound(cpuBound, BYTES_PER_SEARCH_WORKER, 1);
-}
-// Hardcoded optimal values (no env override needed)
-export const PARALLEL_CONCURRENCY = getOptimalParallelism();
-// Configurable via environment variables
-export const MAX_SEARCHABLE_FILE_SIZE = parseEnvInt('MAX_SEARCH_SIZE', MIB, 100 * KIB, 10 * MIB);
-export const MAX_TEXT_FILE_SIZE = parseEnvInt('MAX_FILE_SIZE', 10 * MIB, MIB, 100 * MIB);
-export const DEFAULT_READ_MANY_MAX_TOTAL_SIZE = parseEnvInt('MAX_READ_MANY_TOTAL_SIZE', 512 * KIB, 10 * KIB, 100 * MIB);
-export const DEFAULT_SEARCH_TIMEOUT_MS = parseEnvInt('DEFAULT_SEARCH_TIMEOUT', 5000, 100, 60000);
-const ALLOW_SENSITIVE_FILES = parseEnvBool('FS_CONTEXT_ALLOW_SENSITIVE', false);
-const ENV_DENYLIST = parseEnvList('FS_CONTEXT_DENYLIST');
-const ENV_ALLOWLIST = parseEnvList('FS_CONTEXT_ALLOWLIST');
-/**
- * Number of search worker threads to use.
- * Default: CPU cores (capped at 8 for optimal I/O performance).
- * Configurable via FS_CONTEXT_SEARCH_WORKERS env var.
- */
-export const SEARCH_WORKERS = parseEnvInt('FS_CONTEXT_SEARCH_WORKERS', getDefaultSearchWorkers(), 1, 16);
-// Hardcoded defaults
-export const DEFAULT_MAX_DEPTH = 10;
-export const DEFAULT_LIST_MAX_ENTRIES = 20000;
-export const DEFAULT_SEARCH_MAX_FILES = 20000;
-// Schema limits and defaults
-export const MAX_TREE_DEPTH = 50;
-export const DEFAULT_TREE_DEPTH = 5;
-export const MAX_TREE_ENTRIES = 20000;
-export const DEFAULT_TREE_ENTRIES = 1000;
-export const MAX_LIST_ENTRIES = 20000;
-export const MAX_SEARCH_RESULTS = 10000;
-export const DEFAULT_SEARCH_RESULTS = 100;
-export const MAX_SEARCH_DEPTH = 100;
-export const DEFAULT_SEARCH_CONTENT_RESULTS = 500;
-// Non-configurable constants
-export const MAX_LINE_CONTENT_LENGTH = 200;
-export const BINARY_CHECK_BUFFER_SIZE = 512;
-const DEFAULT_SENSITIVE_PATTERNS = [
-    '.env',
-    '.env.*',
-    '.npmrc',
-    '.pypirc',
-    '.aws/credentials',
-    '.aws/config',
-    '.mcpregistry_*_token',
-    '*.pem',
-    '*.key',
-    '*.p12',
-    '*.pfx',
-    '*.crt',
-    '*.cer',
-    '*id_rsa*',
-    '*id_dsa*',
-];
-export const SENSITIVE_FILE_DENYLIST = [
-    ...(ALLOW_SENSITIVE_FILES ? [] : DEFAULT_SENSITIVE_PATTERNS),
-    ...ENV_DENYLIST,
-];
-export const SENSITIVE_FILE_ALLOWLIST = [...ENV_ALLOWLIST];
-export const KNOWN_BINARY_EXTENSIONS = new Set([
-    '.png',
-    '.jpg',
-    '.jpeg',
-    '.gif',
-    '.webp',
-    '.bmp',
-    '.ico',
-    '.mp3',
-    '.wav',
-    '.flac',
-    '.mp4',
-    '.mov',
-    '.avi',
-    '.mkv',
-    '.webm',
-    '.zip',
-    '.tar',
-    '.gz',
-    '.7z',
-    '.rar',
-    '.exe',
-    '.dll',
-    '.so',
-    '.dylib',
-    '.ttf',
-    '.otf',
-    '.woff',
-    '.woff2',
-    '.pdf',
-    '.doc',
-    '.docx',
-    '.xls',
-    '.xlsx',
-    '.ppt',
-    '.pptx',
-    '.sqlite',
-    '.db',
-    '.wasm',
-    '.bin',
-    '.dat',
-]);
-export const DEFAULT_EXCLUDE_PATTERNS = [
-    '**/node_modules',
-    '**/node_modules/**',
-    '**/dist',
-    '**/dist/**',
-    '**/build',
-    '**/build/**',
-    '**/coverage',
-    '**/coverage/**',
-    '**/.git',
-    '**/.git/**',
-    '**/.vscode',
-    '**/.vscode/**',
-    '**/.idea',
-    '**/.idea/**',
-    '**/.DS_Store',
-    '**/.next',
-    '**/.next/**',
-    '**/.nuxt',
-    '**/.nuxt/**',
-    '**/.output',
-    '**/.output/**',
-    '**/.svelte-kit',
-    '**/.svelte-kit/**',
-    '**/.cache',
-    '**/.cache/**',
-    '**/.yarn',
-    '**/.yarn/**',
-    '**/jspm_packages',
-    '**/jspm_packages/**',
-    '**/bower_components',
-    '**/bower_components/**',
-    '**/out',
-    '**/out/**',
-    '**/tmp',
-    '**/tmp/**',
-    '**/.temp',
-    '**/.temp/**',
-    '**/npm-debug.log',
-    '**/yarn-debug.log',
-    '**/yarn-error.log',
-    '**/Thumbs.db',
-];
-const MIME_TYPES = new Map([
-    ['.png', 'image/png'],
-    ['.jpg', 'image/jpeg'],
-    ['.jpeg', 'image/jpeg'],
-    ['.gif', 'image/gif'],
-    ['.webp', 'image/webp'],
-    ['.svg', 'image/svg+xml'],
-    ['.ico', 'image/x-icon'],
-    ['.bmp', 'image/bmp'],
-    ['.tiff', 'image/tiff'],
-    ['.tif', 'image/tiff'],
-    ['.avif', 'image/avif'],
-    ['.heic', 'image/heic'],
-    ['.heif', 'image/heif'],
-    ['.mp3', 'audio/mpeg'],
-    ['.wav', 'audio/wav'],
-    ['.ogg', 'audio/ogg'],
-    ['.flac', 'audio/flac'],
-    ['.aac', 'audio/aac'],
-    ['.m4a', 'audio/mp4'],
-    ['.wma', 'audio/x-ms-wma'],
-    ['.opus', 'audio/opus'],
-    ['.mp4', 'video/mp4'],
-    ['.webm', 'video/webm'],
-    ['.avi', 'video/x-msvideo'],
-    ['.mov', 'video/quicktime'],
-    ['.wmv', 'video/x-ms-wmv'],
-    ['.mkv', 'video/x-matroska'],
-    ['.flv', 'video/x-flv'],
-    ['.pdf', 'application/pdf'],
-    ['.txt', 'text/plain'],
-    ['.log', 'text/plain'],
-    ['.md', 'text/markdown'],
-    ['.markdown', 'text/markdown'],
-    ['.json', 'application/json'],
-    ['.jsonc', 'application/json'],
-    ['.xml', 'application/xml'],
-    ['.yaml', 'text/yaml'],
-    ['.yml', 'text/yaml'],
-    ['.html', 'text/html'],
-    ['.htm', 'text/html'],
-    ['.css', 'text/css'],
-    ['.js', 'text/javascript'],
-    ['.mjs', 'text/javascript'],
-    ['.cjs', 'text/javascript'],
-    ['.ts', 'text/typescript'],
-    ['.tsx', 'text/typescript'],
-    ['.zip', 'application/zip'],
-    ['.tar', 'application/x-tar'],
-    ['.gz', 'application/gzip'],
-    ['.7z', 'application/x-7z-compressed'],
-    ['.rar', 'application/vnd.rar'],
-    ['.ttf', 'font/ttf'],
-    ['.otf', 'font/otf'],
-    ['.woff', 'font/woff'],
-    ['.woff2', 'font/woff2'],
-    ['.wasm', 'application/wasm'],
-]);
-export function getMimeType(ext) {
-    const lowerExt = ext.toLowerCase();
-    return MIME_TYPES.get(lowerExt) ?? 'application/octet-stream';
-}

package/dist/lib/errors.d.ts

@@ -1,28 +0,0 @@
-import { ErrorCode } from '../config.js';
-export { ErrorCode };
-interface DetailedError {
-    code: ErrorCode;
-    message: string;
-    path?: string;
-    suggestion?: string;
-    details?: Record<string, unknown>;
-}
-export declare function isNodeError(error: unknown): error is NodeJS.ErrnoException;
-export declare function formatUnknownErrorMessage(error: unknown): string;
-export declare function normalizeUnknownError(error: unknown): Error;
-export declare function isAbortError(error: unknown): boolean;
-export declare function isTimeoutLikeError(error: unknown): boolean;
-export declare class McpError extends Error {
-    code: ErrorCode;
-    path?: string | undefined;
-    details?: Record<string, unknown>;
-    constructor(code: ErrorCode, message: string, path?: string | undefined, details?: Record<string, unknown>, cause?: unknown);
-    static notFound(message: string, path?: string, details?: Record<string, unknown>, cause?: unknown): McpError;
-    static invalidInput(message: string, path?: string, details?: Record<string, unknown>, cause?: unknown): McpError;
-    static accessDenied(message: string, path?: string, details?: Record<string, unknown>, cause?: unknown): McpError;
-    static timeout(message: string, path?: string, details?: Record<string, unknown>, cause?: unknown): McpError;
-}
-export declare function classifyError(error: unknown): ErrorCode;
-export declare function createDetailedError(error: unknown, path?: string, additionalDetails?: Record<string, unknown>): DetailedError;
-export declare function formatDetailedError(error: DetailedError): string;
-export declare function getSuggestion(code: ErrorCode): string | undefined;