@j0hanz/filesystem-mcp 1.14.0 → 1.15.0

package/dist/config.js

@@ -1,16 +1,16 @@
 export const ErrorCode = {
-    E_ACCESS_DENIED: 'E_ACCESS_DENIED',
-    E_NOT_FOUND: 'E_NOT_FOUND',
-    E_NOT_FILE: 'E_NOT_FILE',
-    E_NOT_DIRECTORY: 'E_NOT_DIRECTORY',
-    E_TOO_LARGE: 'E_TOO_LARGE',
-    E_TIMEOUT: 'E_TIMEOUT',
-    E_CANCELLED: 'E_CANCELLED',
-    E_INVALID_PATTERN: 'E_INVALID_PATTERN',
-    E_INVALID_INPUT: 'E_INVALID_INPUT',
-    E_PERMISSION_DENIED: 'E_PERMISSION_DENIED',
-    E_SYMLINK_NOT_ALLOWED: 'E_SYMLINK_NOT_ALLOWED',
-    E_UNKNOWN: 'E_UNKNOWN',
+    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) {

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import process from 'node:process';
+import { createTimedAbortSignal } from './lib/abort.js';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from './lib/constants.js';
 import { formatUnknownErrorMessage } from './lib/errors.js';
-import { createTimedAbortSignal } from './lib/fs-helpers.js';
 import { setAllowedDirectoriesResolved } from './lib/paths.js';
 import { CliExitError, parseArgs } from './cli.js';
 import { createServer, startHttpServer, startServer } from './server.js';

package/dist/lib/abort.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,81 @@
+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,9 +1,11 @@
 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 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 const TASK_POLL_INTERVAL_MS = 100;
 export declare const PARALLEL_CONCURRENCY: number;
 export declare const MAX_SEARCHABLE_FILE_SIZE: number;
 export declare const MAX_TEXT_FILE_SIZE: number;

package/dist/lib/constants.js

@@ -1,4 +1,5 @@
 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) {
@@ -9,7 +10,7 @@ export function parseTrueEnvFlag(value) {
 const KIB = 1024;
 const MIB = 1024 * KIB;
 function logInvalidEnvValue(envVar, value, expected, defaultValue) {
-    console.error(`[WARNING] Invalid ${envVar} value: ${value} (must be ${expected}). Using default: ${String(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) {
@@ -66,7 +67,7 @@ function parseEnvLogLevel(envVar, defaultValue) {
     if (VALID_LOG_LEVELS.includes(normalized)) {
         return normalized;
     }
-    console.error(`[WARNING] Invalid ${envVar} value: ${value} (must be ${VALID_LOG_LEVELS.join('|')}). Using default: ${defaultValue}`);
+    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');
@@ -74,6 +75,11 @@ export const DEFAULT_LOG_LEVEL = parseEnvLogLevel('FILESYSTEM_MCP_LOG_LEVEL', 'i
 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);
+// How often (ms) a background task checks the store for client cancellation.
+export const TASK_CANCEL_POLL_MS = 2_000;
+// Suggested poll interval (ms) returned to the SDK/client for automatic task polling.
+// Filesystem operations complete quickly; a short interval avoids unnecessary latency.
+export const TASK_POLL_INTERVAL_MS = 100;
 // Auto-tuned parallelism based on CPU cores (no env override)
 const BYTES_PER_PARALLEL_TASK = 64 * MIB;
 const BYTES_PER_SEARCH_WORKER = 128 * MIB;

package/dist/lib/errors.d.ts

@@ -15,9 +15,13 @@ export declare function isTimeoutLikeError(error: unknown): boolean;
 export declare class McpError extends Error {
     code: ErrorCode;
     path?: string | undefined;
-    details?: Record<string, unknown> | undefined;
-    constructor(code: ErrorCode, message: string, path?: string | undefined, details?: Record<string, unknown> | undefined, cause?: unknown);
+    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 createDetailedError(error: unknown, path?: string, additionalDetails?: Record<string, unknown>): DetailedError;
 export declare function formatDetailedError(error: DetailedError): string;
-export declare function getSuggestion(code: ErrorCode): string;
+export declare function getSuggestion(code: ErrorCode): string | undefined;

package/dist/lib/errors.js

@@ -1,6 +1,7 @@
 import { constants as osConstants } from 'node:os';
 import { getSystemErrorMap, getSystemErrorName, inspect } from 'node:util';
 import { ErrorCode, joinLines } from '../config.js';
+import { getTraceContext } from './observability.js';
 export { ErrorCode };
 function isNativeError(error) {
     const candidate = Error;
@@ -100,20 +101,20 @@ export function normalizeUnknownError(error) {
         : new Error(formatUnknownErrorMessage(error));
 }
 const NODE_ERROR_CODE_MAP = {
-    ENOENT: ErrorCode.E_NOT_FOUND,
-    EACCES: ErrorCode.E_PERMISSION_DENIED,
-    EPERM: ErrorCode.E_PERMISSION_DENIED,
-    ENOTDIR: ErrorCode.E_NOT_DIRECTORY,
-    EISDIR: ErrorCode.E_NOT_FILE,
-    ELOOP: ErrorCode.E_SYMLINK_NOT_ALLOWED,
-    ENAMETOOLONG: ErrorCode.E_INVALID_INPUT,
-    ETIMEDOUT: ErrorCode.E_TIMEOUT,
-    EMFILE: ErrorCode.E_TIMEOUT,
-    ENFILE: ErrorCode.E_TIMEOUT,
-    EBUSY: ErrorCode.E_PERMISSION_DENIED,
-    ENOTEMPTY: ErrorCode.E_NOT_DIRECTORY,
-    EEXIST: ErrorCode.E_INVALID_INPUT,
-    EINVAL: ErrorCode.E_INVALID_INPUT,
+    ENOENT: ErrorCode.NOT_FOUND,
+    EACCES: ErrorCode.PERMISSION_DENIED,
+    EPERM: ErrorCode.PERMISSION_DENIED,
+    ENOTDIR: ErrorCode.NOT_DIRECTORY,
+    EISDIR: ErrorCode.NOT_FILE,
+    ELOOP: ErrorCode.SYMLINK_NOT_ALLOWED,
+    ENAMETOOLONG: ErrorCode.INVALID_INPUT,
+    ETIMEDOUT: ErrorCode.TIMEOUT,
+    EMFILE: ErrorCode.TIMEOUT,
+    ENFILE: ErrorCode.TIMEOUT,
+    EBUSY: ErrorCode.PERMISSION_DENIED,
+    ENOTEMPTY: ErrorCode.NOT_DIRECTORY,
+    EEXIST: ErrorCode.INVALID_INPUT,
+    EINVAL: ErrorCode.INVALID_INPUT,
 };
 function isKnownNodeErrorCode(code) {
     return code in NODE_ERROR_CODE_MAP;
@@ -169,24 +170,39 @@ export class McpError extends Error {
         super(message, { cause });
         this.code = code;
         this.path = path;
-        this.details = details;
         this.name = 'McpError';
         Object.setPrototypeOf(this, McpError.prototype);
+        const trace = getTraceContext();
+        if (trace?.traceparent || details) {
+            this.details = { ...trace, ...details };
+        }
+    }
+    static notFound(message, path, details, cause) {
+        return new McpError(ErrorCode.NOT_FOUND, message, path, details, cause);
+    }
+    static invalidInput(message, path, details, cause) {
+        return new McpError(ErrorCode.INVALID_INPUT, message, path, details, cause);
+    }
+    static accessDenied(message, path, details, cause) {
+        return new McpError(ErrorCode.ACCESS_DENIED, message, path, details, cause);
+    }
+    static timeout(message, path, details, cause) {
+        return new McpError(ErrorCode.TIMEOUT, message, path, details, cause);
     }
 }
 const ERROR_SUGGESTIONS = {
-    [ErrorCode.E_ACCESS_DENIED]: 'Check that the path is within an allowed directory. Use roots to see available workspace roots.',
-    [ErrorCode.E_NOT_FOUND]: 'Verify the path exists. Use ls to explore available files and directories.',
-    [ErrorCode.E_NOT_FILE]: 'The path points to a directory or other non-file. Use ls to explore its contents.',
-    [ErrorCode.E_NOT_DIRECTORY]: 'The path points to a file, not a directory. Use read to read file contents.',
-    [ErrorCode.E_TOO_LARGE]: 'The file exceeds the size limit. Use head to read a partial preview, or narrow the scope of what you read.',
-    [ErrorCode.E_TIMEOUT]: 'The operation timed out. Try a smaller scope (narrower path), fewer results (maxResults), or search fewer files.',
-    [ErrorCode.E_CANCELLED]: 'The operation was cancelled. This is not an error — no retry is needed unless you want to re-run the operation.',
-    [ErrorCode.E_INVALID_PATTERN]: 'The glob or regex pattern is invalid. Check syntax and escape special characters.',
-    [ErrorCode.E_INVALID_INPUT]: 'One or more input parameters are invalid. Check the tool documentation for correct usage.',
-    [ErrorCode.E_PERMISSION_DENIED]: 'Permission denied by the operating system. Check file permissions.',
-    [ErrorCode.E_SYMLINK_NOT_ALLOWED]: 'Symbolic links that escape allowed directories are not permitted for security reasons.',
-    [ErrorCode.E_UNKNOWN]: 'An unexpected error occurred. Check the error message for details.',
+    [ErrorCode.ACCESS_DENIED]: 'Run roots to list allowed directories.',
+    [ErrorCode.NOT_FOUND]: 'Run ls or find to verify the path.',
+    [ErrorCode.NOT_FILE]: 'Target is a directory, not a file.',
+    [ErrorCode.NOT_DIRECTORY]: 'Target is a file, not a directory.',
+    [ErrorCode.TOO_LARGE]: 'Use head/tail or line ranges to read partially.',
+    [ErrorCode.TIMEOUT]: 'Reduce scope, depth, or maxResults.',
+    [ErrorCode.CANCELLED]: undefined,
+    [ErrorCode.INVALID_PATTERN]: 'Check syntax and escape special characters.',
+    [ErrorCode.INVALID_INPUT]: undefined,
+    [ErrorCode.PERMISSION_DENIED]: 'Check OS file permissions.',
+    [ErrorCode.SYMLINK_NOT_ALLOWED]: 'Symlink escapes allowed directories.',
+    [ErrorCode.UNKNOWN]: undefined,
 };
 const NOT_FOUND_PATTERNS = [
     'no such file or directory',
@@ -207,16 +223,16 @@ function classifyMessageError(error) {
     const message = isNativeError(error) ? error.message : String(error);
     const lower = message.toLowerCase();
     if (messageIncludesAny(lower, NOT_FOUND_PATTERNS)) {
-        return ErrorCode.E_NOT_FOUND;
+        return ErrorCode.NOT_FOUND;
     }
     if (messageIncludesAny(lower, PERMISSION_DENIED_PATTERNS)) {
-        return ErrorCode.E_PERMISSION_DENIED;
+        return ErrorCode.PERMISSION_DENIED;
     }
     if (lower.includes('not a directory')) {
-        return ErrorCode.E_NOT_DIRECTORY;
+        return ErrorCode.NOT_DIRECTORY;
     }
     if (lower.includes('is a directory')) {
-        return ErrorCode.E_NOT_FILE;
+        return ErrorCode.NOT_FILE;
     }
     return undefined;
 }
@@ -225,16 +241,16 @@ function classifyError(error) {
     let fallbackCode;
     const terminalCode = walkErrorChain(error, (candidate) => {
         if (isAbortErrorSingle(candidate)) {
-            return ErrorCode.E_CANCELLED;
+            return ErrorCode.CANCELLED;
         }
         if (timeoutCode === undefined && isTimeoutErrorSingle(candidate)) {
-            timeoutCode = ErrorCode.E_TIMEOUT;
+            timeoutCode = ErrorCode.TIMEOUT;
         }
         fallbackCode ??=
             getDirectErrorCode(candidate) ?? classifyMessageError(candidate);
         return undefined;
     });
-    return terminalCode ?? timeoutCode ?? fallbackCode ?? ErrorCode.E_UNKNOWN;
+    return terminalCode ?? timeoutCode ?? fallbackCode ?? ErrorCode.UNKNOWN;
 }
 export function createDetailedError(error, path, additionalDetails) {
     const message = formatUnknownErrorMessage(error);
@@ -242,7 +258,11 @@ export function createDetailedError(error, path, additionalDetails) {
     const suggestion = ERROR_SUGGESTIONS[code];
     const resolvedPath = resolveErrorPath(error, path);
     const details = mergeErrorDetails(error, additionalDetails);
-    const result = { code, message, suggestion };
+    const result = {
+        code,
+        message,
+        ...(suggestion ? { suggestion } : {}),
+    };
     if (resolvedPath)
         result.path = resolvedPath;
     if (details)
@@ -267,12 +287,12 @@ function mergeErrorDetails(error, additionalDetails) {
     return mergedDetails;
 }
 export function formatDetailedError(error) {
-    const lines = [`Error [${error.code}]: ${error.message}`];
-    if (error.path) {
-        lines.push(`Path: ${error.path}`);
+    const lines = [`${error.code}: ${error.message}`];
+    if (error.path && !error.message.includes(error.path)) {
+        lines.push(error.path);
     }
     if (error.suggestion) {
-        lines.push(`Suggestion: ${error.suggestion}`);
+        lines.push(error.suggestion);
     }
     return joinLines(lines);
 }

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

@@ -1,8 +1,8 @@
 import { type Ignore } from 'ignore';
 export declare function needsStatsForSort(sortBy: string): boolean;
-export declare function withOptionalStoppedReason<T extends object, R extends string>(summary: T, stoppedReason: R | undefined): T | (T & {
-    stoppedReason: R;
-});
+export declare function withOptionalStoppedReason<T extends object, R extends string>(summary: T, stoppedReason: R | undefined): T & {
+    stoppedReason?: R;
+};
 export interface DirentLike {
     isDirectory(): boolean;
     isFile(): boolean;

package/dist/lib/file-operations/core.js

@@ -1,5 +1,5 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
 import ignore, {} from 'ignore';
 import { isNodeError } from '../errors.js';
 import { toPosixPath } from '../paths.js';
@@ -40,7 +40,8 @@ export function compareOptionalNumberDesc(left, right, tieBreak) {
 }
 export function stableSortByDerivedString(items, derive, tieBreak) {
     const decorated = [];
-    for (let index = 0; index < items.length; index += 1) {
+    const len = items.length;
+    for (let index = 0; index < len; index++) {
         const item = items[index];
         if (item === undefined)
             continue;
@@ -59,7 +60,8 @@ export function stableSortByDerivedString(items, derive, tieBreak) {
             return tiedCompare;
         return left.index - right.index;
     });
-    for (let index = 0; index < decorated.length; index += 1) {
+    const decoratedLen = decorated.length;
+    for (let index = 0; index < decoratedLen; index++) {
         const entry = decorated[index];
         if (!entry)
             continue;
@@ -74,13 +76,14 @@ export function applyIndexedValues(output, results) {
     }
 }
 export function applyIndexedErrors(options) {
-    for (const failure of options.errors) {
-        const resolvedIndex = options.resolveIndex(failure.index);
+    const { output, errors, resolveIndex, buildValue } = options;
+    for (const failure of errors) {
+        const resolvedIndex = resolveIndex(failure.index);
         if (resolvedIndex === undefined)
             continue;
-        if (resolvedIndex < 0 || resolvedIndex >= options.output.length)
+        if (resolvedIndex < 0 || resolvedIndex >= output.length)
             continue;
-        options.output[resolvedIndex] = options.buildValue(resolvedIndex, failure.error);
+        output[resolvedIndex] = buildValue(resolvedIndex, failure.error);
     }
 }
 export async function isEntryAccessibleByType(entryPath, entryType, rootDirectories, signal, deps) {
@@ -101,8 +104,9 @@ export async function isEntryAccessibleByType(entryPath, entryType, rootDirector
 }
 function parseGitignoreLines(contents) {
     const lines = [];
-    for (const line of contents.split(/\r?\n/u)) {
-        const trimmed = line.trim();
+    const parts = contents.split(/\r?\n/u);
+    for (const part of parts) {
+        const trimmed = part.trim();
         if (trimmed.length > 0) {
             lines.push(trimmed);
         }
@@ -110,13 +114,15 @@ function parseGitignoreLines(contents) {
     return lines;
 }
 export async function loadRootGitignore(root, signal) {
-    const gitignorePath = path.join(root, '.gitignore');
-    let contents;
+    const gitignorePath = join(root, '.gitignore');
     try {
-        contents = await fs.readFile(gitignorePath, {
+        const contents = await readFile(gitignorePath, {
             encoding: 'utf-8',
             signal,
         });
+        const matcher = ignore();
+        matcher.add(parseGitignoreLines(contents));
+        return matcher;
     }
     catch (error) {
         if (isNodeError(error) && error.code === 'ENOENT') {
@@ -124,16 +130,13 @@ export async function loadRootGitignore(root, signal) {
         }
         throw error;
     }
-    const matcher = ignore();
-    matcher.add(parseGitignoreLines(contents));
-    return matcher;
 }
 export function isIgnoredByGitignore(matcher, root, absolutePath, options = {}) {
-    let relative = options.relativePath;
-    relative ??= path.relative(root, absolutePath);
-    if (relative.length === 0)
+    let { relativePath } = options;
+    relativePath ??= relative(root, absolutePath);
+    if (relativePath.length === 0)
         return false;
-    const normalized = toPosixPath(relative);
+    const normalized = toPosixPath(relativePath);
     if (options.isDirectory) {
         return matcher.ignores(normalized.endsWith('/') ? normalized : `${normalized}/`);
     }

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

@@ -1,5 +1,5 @@
 import type { FileInfo, GetMultipleFileInfoResult, ListDirectoryResult } from '../../config.js';
-import type { EntryType } from './core.js';
+import { type EntryType } from './core.js';
 interface FileInfoOptions {
     includeMimeType?: boolean | undefined;
     signal?: AbortSignal | undefined;
@@ -60,7 +60,7 @@ interface ReadMultipleResult {
     endLine?: number;
     linesRead?: number;
     hasMoreLines?: boolean;
-    error?: string;
+    error?: Error;
 }
 interface ReadMultipleOptions {
     encoding?: BufferEncoding;