@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/completions.js

@@ -1,572 +0,0 @@
-import { readdir, realpath, stat } from 'node:fs/promises';
-import { basename, dirname, isAbsolute, join, parse, resolve, sep, } from 'node:path';
-import { z } from 'zod';
-import { getAllowedDirectories, isPathWithinDirectories, normalizePath, toPosixPath, } from './lib/paths.js';
-import { isRecord } from './lib/utils.js';
-import { getSortedToolContracts } from './resources/tool-info.js';
-const MAX_COMPLETION_ITEMS = 100;
-const COMPLETION_RATE_LIMIT_MS = 100;
-const MAX_COMPLETION_CACHE_KEYS = 128;
-// WeakMap keyed by McpServer instance so that each HTTP session gets isolated
-// rate-limit state. In stdio mode there is a single server; in HTTP mode every
-// session creates its own McpServer, so cross-session cache pollution is avoided.
-const completionState = new WeakMap();
-function getCompletionState(server) {
-    let state = completionState.get(server);
-    if (state === undefined) {
-        state = { lastCallMs: new Map(), lastResult: new Map() };
-        completionState.set(server, state);
-    }
-    return state;
-}
-function extractTopicCompletions(instructions) {
-    const headers = [];
-    for (const line of instructions.split('\n')) {
-        if (line.startsWith('## ')) {
-            const header = line.slice(3).trim().toLowerCase();
-            if (header)
-                headers.push(header);
-        }
-    }
-    return headers;
-}
-function extractToolNameCompletions() {
-    return getSortedToolContracts().map((contract) => contract.name);
-}
-const PATH_ARGUMENTS = new Set([
-    'path',
-    'source',
-    'destination',
-    'original',
-    'modified',
-    'directory',
-    'file',
-    'root',
-    'cwd',
-]);
-const DESTINATION_CONTEXT_KEYS = ['source', 'path', 'cwd', 'root'];
-const PRIMARY_PATH_CONTEXT_KEYS = ['path', 'cwd', 'root'];
-const DEFAULT_CONTEXT_KEYS = ['path', 'source', 'cwd', 'root'];
-function extractEnumValuesFromSchema(argumentName, schema) {
-    const properties = getInputSchemaProperties(schema);
-    if (!properties || typeof properties !== 'object')
-        return undefined;
-    for (const [key, value] of Object.entries(properties)) {
-        if (key.toLowerCase() !== argumentName)
-            continue;
-        if (value === null || typeof value !== 'object' || !('enum' in value)) {
-            return undefined;
-        }
-        const enumValues = value.enum;
-        if (!Array.isArray(enumValues))
-            return undefined;
-        const stringValues = enumValues.filter((entry) => typeof entry === 'string');
-        return stringValues.length > 0 ? stringValues : undefined;
-    }
-    return undefined;
-}
-function getInputSchemaProperties(schema) {
-    const { properties } = z.toJSONSchema(schema, { io: 'input' });
-    if (!properties || typeof properties !== 'object')
-        return undefined;
-    return properties;
-}
-function intersectEnumValueSets(valueSets) {
-    const [firstSet, ...restSets] = valueSets;
-    if (!firstSet)
-        return [];
-    return firstSet.filter((value) => restSets.every((candidateSet) => candidateSet.includes(value)));
-}
-function buildEnumArgumentValues() {
-    const valuesByArgument = new Map();
-    for (const contract of getSortedToolContracts()) {
-        const properties = getInputSchemaProperties(contract.inputSchema);
-        if (!properties || typeof properties !== 'object')
-            continue;
-        for (const key of Object.keys(properties)) {
-            const normalizedKey = key.toLowerCase();
-            const values = extractEnumValuesFromSchema(normalizedKey, contract.inputSchema);
-            if (!values)
-                continue;
-            const existing = valuesByArgument.get(normalizedKey) ?? [];
-            existing.push(values);
-            valuesByArgument.set(normalizedKey, existing);
-        }
-    }
-    const result = new Map();
-    for (const [argumentName, valueSets] of valuesByArgument) {
-        const values = valueSets.length === 1
-            ? (valueSets[0] ?? [])
-            : intersectEnumValueSets(valueSets);
-        if (values.length > 0) {
-            result.set(argumentName, values);
-        }
-    }
-    return result;
-}
-function isPathLikeArgumentName(argName) {
-    return (PATH_ARGUMENTS.has(argName) ||
-        argName.endsWith('paths') ||
-        argName.endsWith('path') ||
-        argName.endsWith('files') ||
-        argName.endsWith('file') ||
-        argName.endsWith('dirs') ||
-        argName.endsWith('dir'));
-}
-function getEnumCompletions(argName, currentValue, enumArgumentValues) {
-    const values = enumArgumentValues.get(argName);
-    if (!values)
-        return undefined;
-    const prefix = currentValue.toLowerCase();
-    const filtered = prefix
-        ? values.filter((v) => v.startsWith(prefix))
-        : [...values];
-    return buildCompletionResult(filtered);
-}
-function isTemplateVariableChar(char) {
-    const code = char.charCodeAt(0);
-    const isDigit = code >= 48 && code <= 57;
-    const isUpper = code >= 65 && code <= 90;
-    const isLower = code >= 97 && code <= 122;
-    return isDigit || isUpper || isLower || code === 95;
-}
-function normalizeTemplateVariable(raw) {
-    let normalized = '';
-    for (const char of raw) {
-        if (isTemplateVariableChar(char)) {
-            normalized += char.toLowerCase();
-        }
-    }
-    return normalized;
-}
-function parseResourceReference(value) {
-    if (!isRecord(value))
-        return undefined;
-    if (value['type'] !== 'ref/resource')
-        return undefined;
-    const { uri } = value;
-    if (typeof uri !== 'string')
-        return undefined;
-    return { type: 'ref/resource', uri };
-}
-function extractTemplateVariables(uri) {
-    const vars = [];
-    let index = 0;
-    while (index < uri.length) {
-        const start = uri.indexOf('{', index);
-        if (start === -1)
-            break;
-        const end = uri.indexOf('}', start + 1);
-        if (end === -1)
-            break;
-        const normalized = normalizeTemplateVariable(uri.slice(start + 1, end));
-        if (normalized.length > 0)
-            vars.push(normalized);
-        index = end + 1;
-    }
-    return vars;
-}
-function isPathArgumentFromReference(argumentName, ref) {
-    const resourceRef = parseResourceReference(ref);
-    if (!resourceRef)
-        return false;
-    const normalizedArg = argumentName.toLowerCase();
-    const templateVars = extractTemplateVariables(resourceRef.uri);
-    if (templateVars.length === 0)
-        return false;
-    const matchesVariable = templateVars.includes(normalizedArg);
-    if (!matchesVariable)
-        return false;
-    if (isPathLikeArgumentName(normalizedArg))
-        return true;
-    if (resourceRef.uri.toLowerCase().includes('file:///'))
-        return true;
-    const uriLooksPathLike = resourceRef.uri.includes('/') &&
-        (resourceRef.uri.toLowerCase().includes('path') ||
-            resourceRef.uri.toLowerCase().includes('file') ||
-            resourceRef.uri.toLowerCase().includes('dir') ||
-            resourceRef.uri.toLowerCase().includes('root') ||
-            resourceRef.uri.toLowerCase().includes('cwd'));
-    return uriLooksPathLike;
-}
-function extractContextArguments(value) {
-    if (!isRecord(value))
-        return undefined;
-    const context = value['arguments'];
-    if (!isRecord(context))
-        return undefined;
-    const normalized = {};
-    let count = 0;
-    for (const [key, entryValue] of Object.entries(context)) {
-        if (typeof entryValue !== 'string')
-            continue;
-        normalized[key.toLowerCase()] = entryValue;
-        count += 1;
-    }
-    if (count === 0)
-        return undefined;
-    return normalized;
-}
-function serializeCompletionRef(ref) {
-    if (!isRecord(ref) || typeof ref['type'] !== 'string') {
-        return { type: 'unknown' };
-    }
-    if (ref['type'] === 'ref/prompt' && typeof ref['name'] === 'string') {
-        return { type: ref['type'], name: ref['name'] };
-    }
-    if (ref['type'] === 'ref/resource' && typeof ref['uri'] === 'string') {
-        return { type: ref['type'], uri: ref['uri'] };
-    }
-    return { type: ref['type'] };
-}
-function serializeContextArguments(contextArguments) {
-    if (!contextArguments)
-        return [];
-    return Object.entries(contextArguments).sort(([left], [right]) => left.localeCompare(right));
-}
-function buildCompletionCacheKey(params) {
-    return JSON.stringify({
-        argumentName: params.argumentName.toLowerCase(),
-        value: params.value,
-        ref: serializeCompletionRef(params.ref),
-        contextArguments: serializeContextArguments(params.contextArguments),
-    });
-}
-function rememberCompletionCacheValue(cache, key, value) {
-    if (cache.has(key)) {
-        cache.delete(key);
-    }
-    cache.set(key, value);
-    while (cache.size > MAX_COMPLETION_CACHE_KEYS) {
-        const oldest = cache.keys().next();
-        if (oldest.done)
-            break;
-        cache.delete(oldest.value);
-    }
-}
-function hasTrailingSeparator(value) {
-    return value.endsWith(sep) || value.endsWith('/') || value.endsWith('\\');
-}
-function isAbsolutePathInput(value) {
-    return (isAbsolute(value) ||
-        /^[A-Za-z]:[\\/]/u.test(value) ||
-        value.startsWith('\\\\'));
-}
-function resolveFromBase(base, rawValue, trailingSeparator) {
-    const normalizedValue = normalizePath(resolve(base, rawValue));
-    if (trailingSeparator) {
-        return { searchDir: normalizedValue, prefix: '' };
-    }
-    return {
-        searchDir: dirname(normalizedValue),
-        prefix: basename(normalizedValue),
-    };
-}
-function resolveNamedRootContext(currentValue, allowed) {
-    const parsed = parseNamedRootInput(currentValue);
-    if (!parsed)
-        return undefined;
-    const root = findAllowedRootByName(parsed.rootName, allowed);
-    if (!root)
-        return undefined;
-    const trailingSeparator = hasTrailingSeparator(currentValue);
-    return resolveFromBase(root, parsed.remainder, trailingSeparator);
-}
-function resolveNamedRootPath(value, allowed) {
-    const parsed = parseNamedRootInput(value);
-    if (!parsed)
-        return undefined;
-    const root = findAllowedRootByName(parsed.rootName, allowed);
-    if (!root)
-        return undefined;
-    return normalizePath(resolve(root, parsed.remainder));
-}
-function parseNamedRootInput(value) {
-    const normalizedInput = toPosixPath(value);
-    const [rootName, ...rest] = normalizedInput.split('/');
-    if (!rootName)
-        return undefined;
-    return { rootName, remainder: rest.join(sep) };
-}
-function findAllowedRootByName(rootName, allowed) {
-    const normalizedRootName = rootName.toLowerCase();
-    return allowed.find((candidate) => basename(candidate).toLowerCase() === normalizedRootName);
-}
-function chooseContextKeys(argumentName) {
-    const normalized = argumentName.toLowerCase();
-    if (normalized === 'destination') {
-        return [...DESTINATION_CONTEXT_KEYS];
-    }
-    if (normalized === 'path' ||
-        normalized === 'source' ||
-        normalized === 'original' ||
-        normalized === 'modified' ||
-        normalized === 'file') {
-        return [...PRIMARY_PATH_CONTEXT_KEYS];
-    }
-    return [...DEFAULT_CONTEXT_KEYS];
-}
-function hasContextArguments(contextArguments) {
-    return (contextArguments !== undefined && Object.keys(contextArguments).length > 0);
-}
-function resolveContextCandidatePath(candidate, allowed) {
-    if (isAbsolutePathInput(candidate)) {
-        return normalizePath(candidate);
-    }
-    if (allowed.length === 1) {
-        const base = allowed[0];
-        if (!base)
-            return undefined;
-        return normalizePath(resolve(base, candidate));
-    }
-    return resolveNamedRootPath(candidate, allowed);
-}
-async function toAllowedContextDirectory(resolved, allowed) {
-    const parent = dirname(resolved);
-    if (await isAllowedCompletionDirectory(resolved, allowed)) {
-        return resolved;
-    }
-    return (await isAllowedCompletionDirectory(parent, allowed))
-        ? parent
-        : undefined;
-}
-async function isAllowedCompletionDirectory(path, allowed) {
-    if (!isPathWithinDirectories(path, allowed))
-        return false;
-    try {
-        const [stats, resolvedRealPath] = await Promise.all([
-            stat(path),
-            realpath(path),
-        ]);
-        if (!stats.isDirectory())
-            return false;
-        return isPathWithinDirectories(normalizePath(resolvedRealPath), allowed);
-    }
-    catch {
-        return false;
-    }
-}
-async function resolveContextBaseDirectory(argumentName, contextArguments, allowed) {
-    if (!hasContextArguments(contextArguments)) {
-        return undefined;
-    }
-    const keys = chooseContextKeys(argumentName);
-    for (const key of keys) {
-        const candidate = contextArguments[key];
-        if (!candidate || candidate.trim().length === 0)
-            continue;
-        const resolved = resolveContextCandidatePath(candidate, allowed);
-        if (!resolved)
-            continue;
-        const baseDirectory = await toAllowedContextDirectory(resolved, allowed);
-        if (baseDirectory)
-            return baseDirectory;
-    }
-    return undefined;
-}
-function withDirectorySeparator(value) {
-    return value.endsWith(sep) ? value : `${value}${sep}`;
-}
-function buildCompletionResult(values) {
-    return {
-        values: values.slice(0, MAX_COMPLETION_ITEMS),
-        total: values.length,
-        hasMore: values.length > MAX_COMPLETION_ITEMS,
-    };
-}
-function buildCompletionResponse(result) {
-    return { completion: result };
-}
-function sortCompletionMatches(matches) {
-    matches.sort((left, right) => {
-        const leftIsDir = left.endsWith(sep);
-        const rightIsDir = right.endsWith(sep);
-        if (leftIsDir && !rightIsDir)
-            return -1;
-        if (!leftIsDir && rightIsDir)
-            return 1;
-        return left.localeCompare(right);
-    });
-}
-function mergeCompletionMatches(...matchGroups) {
-    const uniqueMatches = new Set();
-    for (const group of matchGroups) {
-        for (const match of group) {
-            uniqueMatches.add(match);
-        }
-    }
-    const merged = [...uniqueMatches];
-    sortCompletionMatches(merged);
-    return merged;
-}
-function getRootPrefix(currentValue) {
-    const normalizedInput = toPosixPath(currentValue);
-    return (normalizedInput.split('/')[0] ?? '').toLowerCase();
-}
-function collectAllowedRoots(allowed, predicate) {
-    const matches = [];
-    for (const root of allowed) {
-        if (predicate(root)) {
-            matches.push(withDirectorySeparator(root));
-        }
-    }
-    return matches;
-}
-function getSearchContext(currentValue, allowed, contextBase) {
-    const trailingSeparator = hasTrailingSeparator(currentValue);
-    if (isAbsolutePathInput(currentValue)) {
-        return resolveFromBase(parse(currentValue).root || sep, currentValue, trailingSeparator);
-    }
-    const namedRootContext = resolveNamedRootContext(currentValue, allowed);
-    if (namedRootContext) {
-        return namedRootContext;
-    }
-    if (contextBase) {
-        if (currentValue.length === 0) {
-            return { searchDir: contextBase, prefix: '' };
-        }
-        return resolveFromBase(contextBase, currentValue, trailingSeparator);
-    }
-    if (allowed.length === 1) {
-        const base = allowed[0];
-        if (base) {
-            return resolveFromBase(base, currentValue, trailingSeparator);
-        }
-    }
-    return undefined;
-}
-async function findMatchesInDirectory(searchDir, prefix, allowed) {
-    const matches = [];
-    if (!(await isAllowedCompletionDirectory(searchDir, allowed))) {
-        return matches;
-    }
-    try {
-        const entries = await readdir(searchDir, { withFileTypes: true });
-        const lowerPrefix = prefix.toLowerCase();
-        for (const entry of entries) {
-            if (entry.name.toLowerCase().startsWith(lowerPrefix)) {
-                const fullPath = join(searchDir, entry.name);
-                const isDir = entry.isDirectory();
-                matches.push(isDir ? `${fullPath}${sep}` : fullPath);
-            }
-        }
-    }
-    catch {
-        // Access denied or not found, ignore
-    }
-    return matches;
-}
-function findRootPrefixMatches(currentValue, allowed) {
-    const rootPrefix = getRootPrefix(currentValue);
-    if (!rootPrefix) {
-        return collectAllowedRoots(allowed, () => true);
-    }
-    return collectAllowedRoots(allowed, (root) => basename(root).toLowerCase().startsWith(rootPrefix));
-}
-function findMatchingRoots(searchDir, prefix, allowed) {
-    const lowerPrefix = prefix.toLowerCase();
-    const normalizedSearchDir = normalizePath(searchDir);
-    return collectAllowedRoots(allowed, (root) => {
-        const rootDir = dirname(root);
-        // Check if root is a direct child of searchDir
-        if (normalizePath(rootDir) !== normalizedSearchDir)
-            return false;
-        return basename(root).toLowerCase().startsWith(lowerPrefix);
-    });
-}
-async function getPathCompletions(currentValue, options = {}) {
-    const allowed = getAllowedDirectories();
-    try {
-        const contextBase = await resolveContextBaseDirectory(options.argumentName ?? '', options.contextArguments, allowed);
-        // If no value and no context base, suggest roots.
-        if (!currentValue && !contextBase) {
-            return buildCompletionResult(allowed);
-        }
-        const context = getSearchContext(currentValue, allowed, contextBase);
-        if (!context) {
-            return buildCompletionResult(findRootPrefixMatches(currentValue, allowed));
-        }
-        const { searchDir, prefix } = context;
-        const dirMatches = await findMatchesInDirectory(searchDir, prefix, allowed);
-        const rootMatches = findMatchingRoots(searchDir, prefix, allowed);
-        return buildCompletionResult(mergeCompletionMatches(dirMatches, rootMatches));
-    }
-    catch {
-        return { values: [] };
-    }
-}
-function handleTopicAndToolCompletions(ref, argName, argumentValue, topicValues, toolNameValues) {
-    if (!isRecord(ref))
-        return undefined;
-    const currentValue = argumentValue.toLowerCase();
-    if (ref['type'] === 'ref/prompt' && argName === 'topic') {
-        const filtered = currentValue
-            ? topicValues.filter((v) => v.startsWith(currentValue))
-            : topicValues;
-        return buildCompletionResponse(buildCompletionResult(filtered));
-    }
-    if (ref['type'] === 'ref/prompt' &&
-        ref['name'] === 'get-tool-help' &&
-        argName === 'name') {
-        const filtered = currentValue
-            ? toolNameValues.filter((value) => value.startsWith(currentValue))
-            : toolNameValues;
-        return buildCompletionResponse(buildCompletionResult(filtered));
-    }
-    if (ref['type'] === 'ref/resource' &&
-        ref['uri'] === 'internal://tool-info/{name}' &&
-        argName === 'name') {
-        const filtered = currentValue
-            ? toolNameValues.filter((value) => value.startsWith(currentValue))
-            : toolNameValues;
-        return buildCompletionResponse(buildCompletionResult(filtered));
-    }
-    return undefined;
-}
-export function registerCompletions(server, instructions = '') {
-    const topicValues = extractTopicCompletions(instructions);
-    const toolNameValues = extractToolNameCompletions();
-    const enumArgumentValues = buildEnumArgumentValues();
-    server.server.setRequestHandler('completion/complete', async (request) => {
-        const { params } = request;
-        const { argument, ref } = params;
-        const argName = argument.name.toLowerCase();
-        const predef = handleTopicAndToolCompletions(ref, argName, argument.value, topicValues, toolNameValues);
-        if (predef)
-            return predef;
-        const enumResult = getEnumCompletions(argName, argument.value, enumArgumentValues);
-        if (enumResult) {
-            return buildCompletionResponse(enumResult);
-        }
-        const isPathArg = isPathLikeArgumentName(argName) ||
-            isPathArgumentFromReference(argName, ref);
-        if (!isPathArg) {
-            return buildCompletionResponse(buildCompletionResult([]));
-        }
-        const contextArguments = extractContextArguments(params.context);
-        const cacheKey = buildCompletionCacheKey({
-            argumentName: argName,
-            value: argument.value,
-            ref,
-            ...(contextArguments ? { contextArguments } : {}),
-        });
-        const now = Date.now();
-        const sessionState = getCompletionState(server);
-        const lastCallMs = sessionState.lastCallMs.get(cacheKey) ?? 0;
-        if (now - lastCallMs < COMPLETION_RATE_LIMIT_MS) {
-            const lastResult = sessionState.lastResult.get(cacheKey);
-            if (lastResult) {
-                return buildCompletionResponse(lastResult);
-            }
-            return buildCompletionResponse(buildCompletionResult([]));
-        }
-        rememberCompletionCacheValue(sessionState.lastCallMs, cacheKey, now);
-        const { value } = argument;
-        const completions = await getPathCompletions(value, {
-            argumentName: argName,
-            ...(contextArguments ? { contextArguments } : {}),
-        });
-        rememberCompletionCacheValue(sessionState.lastResult, cacheKey, completions);
-        return buildCompletionResponse(completions);
-    });
-}

package/dist/config.d.ts

@@ -1,119 +0,0 @@
-export type FileType = 'file' | 'directory' | 'symlink' | 'other';
-export interface FileInfo {
-    readonly name: string;
-    readonly path: string;
-    readonly type: FileType;
-    readonly size: number;
-    readonly tokenEstimate?: number;
-    readonly created: Date;
-    readonly modified: Date;
-    readonly accessed: Date;
-    readonly permissions: string;
-    readonly isHidden: boolean;
-    readonly mimeType?: string;
-    readonly symlinkTarget?: string;
-}
-export interface DirectoryEntry {
-    readonly name: string;
-    readonly path: string;
-    readonly relativePath: string;
-    readonly type: FileType;
-    readonly size?: number;
-    readonly modified?: Date;
-    readonly symlinkTarget?: string;
-}
-export interface ListDirectoryResult {
-    readonly path: string;
-    readonly entries: readonly DirectoryEntry[];
-    readonly summary: {
-        readonly totalEntries: number;
-        readonly entriesScanned?: number;
-        readonly entriesVisible?: number;
-        readonly totalFiles: number;
-        readonly totalDirectories: number;
-        readonly maxDepthReached: number;
-        readonly truncated: boolean;
-        readonly stoppedReason?: 'maxEntries' | 'aborted';
-        readonly skippedInaccessible: number;
-        readonly symlinksNotFollowed: number;
-    };
-}
-export interface SearchResult {
-    readonly path: string;
-    readonly type: FileType;
-    readonly size?: number;
-    readonly modified?: Date;
-}
-export interface SearchFilesResult {
-    readonly basePath: string;
-    readonly pattern: string;
-    readonly results: readonly SearchResult[];
-    readonly summary: {
-        readonly matched: number;
-        readonly truncated: boolean;
-        readonly skippedInaccessible: number;
-        readonly filesScanned: number;
-        readonly stoppedReason?: 'maxResults' | 'maxFiles' | 'timeout';
-    };
-}
-export interface ContentMatch {
-    readonly file: string;
-    readonly line: number;
-    readonly content: string;
-    readonly contextBefore?: readonly string[];
-    readonly contextAfter?: readonly string[];
-    readonly matchCount: number;
-}
-export interface SearchContentResult {
-    readonly basePath: string;
-    readonly pattern: string;
-    readonly filePattern: string;
-    readonly matches: readonly ContentMatch[];
-    readonly summary: {
-        readonly filesScanned: number;
-        readonly filesMatched: number;
-        readonly matches: number;
-        readonly truncated: boolean;
-        readonly skippedTooLarge: number;
-        readonly skippedBinary: number;
-        readonly skippedInaccessible: number;
-        readonly stoppedReason?: 'maxResults' | 'maxFiles' | 'timeout';
-    };
-}
-export interface MultipleFileInfoResult {
-    readonly path: string;
-    readonly info?: FileInfo;
-    readonly error?: Error;
-}
-export interface GetMultipleFileInfoResult {
-    readonly results: readonly MultipleFileInfoResult[];
-    readonly summary: {
-        readonly total: number;
-        readonly succeeded: number;
-        readonly failed: number;
-        readonly totalSize: number;
-    };
-}
-export declare const ErrorCode: {
-    readonly ACCESS_DENIED: "ACCESS_DENIED";
-    readonly NOT_FOUND: "NOT_FOUND";
-    readonly NOT_FILE: "NOT_FILE";
-    readonly NOT_DIRECTORY: "NOT_DIRECTORY";
-    readonly TOO_LARGE: "TOO_LARGE";
-    readonly TIMEOUT: "TIMEOUT";
-    readonly CANCELLED: "CANCELLED";
-    readonly INVALID_PATTERN: "INVALID_PATTERN";
-    readonly INVALID_INPUT: "INVALID_INPUT";
-    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
-    readonly SYMLINK_NOT_ALLOWED: "SYMLINK_NOT_ALLOWED";
-    readonly UNKNOWN: "UNKNOWN";
-};
-export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
-export declare function formatBytes(bytes: number): string;
-export declare function joinLines(lines: readonly string[]): string;
-interface OperationSummary {
-    truncated?: boolean;
-    truncatedReason?: string;
-}
-export declare function formatOperationSummary(summary: OperationSummary): string;
-export {};