@j0hanz/fs-context-mcp 2.2.0 → 2.3.0

package/dist/lib/file-operations/search-content.js

@@ -10,7 +10,7 @@ import { ErrorCode, McpError } from '../errors.js';
 import { assertNotAborted, createTimedAbortSignal, isProbablyBinary, withAbort, } from '../fs-helpers.js';
 import { publishOpsTraceEnd, publishOpsTraceError, publishOpsTraceStart, shouldPublishOpsTrace, } from '../observability.js';
 import { assertAllowedFileAccess, isSensitivePath } from '../path-policy.js';
-import { validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
+import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
 import { globEntries } from './glob-engine.js';
 const INTERNAL_MAX_RESULTS = 500;
 const DEFAULTS = {
@@ -29,10 +29,11 @@ const DEFAULTS = {
     baseNameMatch: false,
     caseSensitiveFileMatch: true,
 };
-function mergeOptions(partial) {
-    const rest = { ...partial };
-    delete rest.signal;
-    return { ...DEFAULTS, ...rest };
+function mergeOptions(options) {
+    const optionsCopy = { ...options };
+    delete optionsCopy.signal;
+    delete optionsCopy.onProgress;
+    return { ...DEFAULTS, ...optionsCopy };
 }
 function validatePattern(pattern, options) {
     if (options.isLiteral && !options.wholeWord) {
@@ -328,18 +329,44 @@ function createScanSummary() {
         stoppedReason: undefined,
     };
 }
+function isTimeoutAbort(error) {
+    return (error instanceof Error &&
+        error.name === 'AbortError' &&
+        error.message.toLowerCase().includes('timed out'));
+}
+function buildTimeoutSearchResult(root, pattern, filePattern) {
+    const summary = createScanSummary();
+    markTruncated(summary, 'timeout');
+    return buildSearchResult(root, pattern, filePattern, [], summary);
+}
+function stopIfAborted(signal, summary) {
+    if (!signal.aborted)
+        return false;
+    markTruncated(summary, 'timeout');
+    return true;
+}
 function shouldStopCollecting(summary, maxFilesScanned, signal) {
-    if (signal.aborted) {
-        markTruncated(summary, 'timeout');
+    if (stopIfAborted(signal, summary))
         return true;
-    }
     if (summary.filesScanned >= maxFilesScanned) {
         markTruncated(summary, 'maxFiles');
         return true;
     }
     return false;
 }
-async function resolveEntryPath(entry, signal) {
+function resolveNonSymlinkEntryPath(root, entryPath) {
+    const normalized = normalizePath(entryPath);
+    if (!isPathWithinDirectories(normalized, [root]))
+        return null;
+    return {
+        resolvedPath: normalized,
+        requestedPath: entryPath,
+    };
+}
+async function resolveEntryPath(entry, root, signal) {
+    if (!entry.dirent.isSymbolicLink()) {
+        return resolveNonSymlinkEntryPath(root, entry.path);
+    }
     try {
         const details = await validateExistingPathDetailed(entry.path, signal);
         return {
@@ -351,14 +378,14 @@ async function resolveEntryPath(entry, signal) {
         return null;
     }
 }
-async function* collectFromStream(stream, opts, signal, summary, onProgress) {
+async function* collectFromStream(stream, root, opts, signal, summary, onProgress) {
     for await (const entry of stream) {
         if (!entry.dirent.isFile())
             continue;
         if (shouldStopCollecting(summary, opts.maxFilesScanned, signal)) {
             break;
         }
-        const resolved = await resolveEntryPath(entry, signal);
+        const resolved = await resolveEntryPath(entry, root, signal);
         if (!resolved) {
             summary.skippedInaccessible++;
             continue;
@@ -389,15 +416,13 @@ function collectFilesStream(root, opts, signal, onProgress) {
         suppressErrors: true,
     });
     return {
-        stream: collectFromStream(stream, opts, signal, summary, onProgress),
+        stream: collectFromStream(stream, root, opts, signal, summary, onProgress),
         summary,
     };
 }
 function shouldStopOnSignalOrLimit(signal, matchesCount, maxResults, summary) {
-    if (signal.aborted) {
-        markTruncated(summary, 'timeout');
+    if (stopIfAborted(signal, summary))
         return true;
-    }
     if (matchesCount >= maxResults) {
         markTruncated(summary, 'maxResults');
         return true;
@@ -642,11 +667,24 @@ class SearchWorkerPool {
         const scanRequest = this.buildScanRequest(id, request);
         const promise = this.createScanPromise(slot, worker, scanRequest);
         const cancel = this.createCancel(slot, worker, id);
-        const outcome = promise.then((result) => ({ task, result }), (error) => ({
-            task,
-            error: error instanceof Error ? error : new Error(String(error)),
-        }));
-        const task = { id, promise, cancel, outcome };
+        let resolveOutcome = () => { };
+        const outcome = new Promise((resolve) => {
+            resolveOutcome = resolve;
+        });
+        const task = {
+            id,
+            promise,
+            cancel,
+            outcome,
+        };
+        void promise.then((result) => {
+            resolveOutcome({ task, result });
+        }, (error) => {
+            resolveOutcome({
+                task,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        });
         return task;
     }
     async close() {
@@ -929,15 +967,19 @@ async function executeSearch(root, pattern, opts, signal, onProgress) {
 export async function searchContent(basePath, pattern, options = {}) {
     const opts = mergeOptions(options);
     const { signal, cleanup } = createTimedAbortSignal(options.signal, opts.timeoutMs);
+    let resolvedBasePath;
     try {
         const details = await validateExistingPathDetailed(basePath, signal);
+        resolvedBasePath = details.resolvedPath;
         const stats = await withAbort(fsp.stat(details.resolvedPath), signal);
         if (stats.isDirectory()) {
             const root = await validateExistingDirectory(details.resolvedPath, signal);
+            resolvedBasePath = root;
             return await executeSearch(root, pattern, opts, signal, options.onProgress);
         }
         if (stats.isFile()) {
             const baseDir = path.dirname(details.requestedPath);
+            resolvedBasePath = baseDir;
             return await executeSearchSingleFile({
                 resolvedPath: details.resolvedPath,
                 requestedPath: details.requestedPath,
@@ -945,8 +987,13 @@ export async function searchContent(basePath, pattern, options = {}) {
         }
         throw new McpError(ErrorCode.E_INVALID_INPUT, `Path must be a file or directory: ${basePath}`, basePath);
     }
+    catch (error) {
+        if (isTimeoutAbort(error)) {
+            return buildTimeoutSearchResult(resolvedBasePath ?? basePath, pattern, opts.filePattern);
+        }
+        throw error;
+    }
     finally {
         cleanup();
     }
 }
-//# sourceMappingURL=search-content.js.map

package/dist/lib/file-operations/search-files.d.ts

@@ -20,4 +20,3 @@ interface Sortable {
 export declare function sortSearchResults(results: Sortable[], sortBy: 'name' | 'size' | 'modified' | 'path'): void;
 export declare function searchFiles(basePath: string, pattern: string, excludePatterns?: readonly string[], options?: SearchFilesOptions): Promise<SearchFilesResult>;
 export {};
-//# sourceMappingURL=search-files.d.ts.map

package/dist/lib/file-operations/search-files.js

@@ -2,7 +2,7 @@ import * as path from 'node:path';
 import { DEFAULT_SEARCH_MAX_FILES, DEFAULT_SEARCH_TIMEOUT_MS, } from '../constants.js';
 import { createTimedAbortSignal } from '../fs-helpers.js';
 import { isSensitivePath } from '../path-policy.js';
-import { validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
+import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
 import { isIgnoredByGitignore, loadRootGitignore } from './gitignore.js';
 import { globEntries } from './glob-engine.js';
 // Internal default for find tool - not exposed to MCP users
@@ -126,22 +126,33 @@ async function collectFromStream(stream, root, gitignoreMatcher, normalized, nee
             isIgnoredByGitignore(gitignoreMatcher, root, entry.path)) {
             continue;
         }
-        try {
-            const validated = await validateExistingPathDetailed(entry.path, signal);
-            if (isSensitivePath(validated.requestedPath, validated.resolvedPath)) {
-                state.skippedInaccessible++;
-                continue;
-            }
-        }
-        catch {
+        const entryType = resolveEntryType(entry.dirent);
+        const isAccessible = await isEntryAccessible(entry, entryType, root, signal);
+        if (!isAccessible) {
             state.skippedInaccessible++;
             continue;
         }
-        handleEntry(entry, resolveEntryType(entry.dirent), needsStats, normalized, state);
+        handleEntry(entry, entryType, needsStats, normalized, state);
         if (state.truncated)
             break;
     }
 }
+async function isEntryAccessible(entry, entryType, root, signal) {
+    if (entryType === 'symlink') {
+        try {
+            const validated = await validateExistingPathDetailed(entry.path, signal);
+            return !isSensitivePath(validated.requestedPath, validated.resolvedPath);
+        }
+        catch {
+            return false;
+        }
+    }
+    const normalized = normalizePath(entry.path);
+    if (!isPathWithinDirectories(normalized, [root])) {
+        return false;
+    }
+    return !isSensitivePath(entry.path, normalized);
+}
 async function collectSearchResults(root, pattern, excludePatterns, normalized, signal) {
     const needsStats = needsStatsForSort(normalized.sortBy);
     const stream = buildSearchStream(root, pattern, excludePatterns, normalized, needsStats);
@@ -238,4 +249,3 @@ export async function searchFiles(basePath, pattern, excludePatterns = [], optio
         cleanup();
     }
 }
-//# sourceMappingURL=search-files.js.map

package/dist/lib/file-operations/search-worker.d.ts

@@ -1,3 +1,2 @@
 import type { ScanRequest, ScanResult, WorkerResponse } from './search-content.js';
 export type { WorkerResponse, ScanRequest, ScanResult };
-//# sourceMappingURL=search-worker.d.ts.map

package/dist/lib/file-operations/search-worker.js

@@ -94,4 +94,3 @@ if (parentPort) {
         console.error(`[SearchWorker] Started with threadId=${String(data.threadId)}`);
     }
 }
-//# sourceMappingURL=search-worker.js.map

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

@@ -22,4 +22,3 @@ export interface TreeResult {
 export declare function formatTreeAscii(tree: TreeEntry): string;
 export declare function treeDirectory(dirPath: string, options?: TreeOptions): Promise<TreeResult>;
 export {};
-//# sourceMappingURL=tree.d.ts.map

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

@@ -2,7 +2,7 @@ import * as path from 'node:path';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_TIMEOUT_MS, } from '../constants.js';
 import { createTimedAbortSignal } from '../fs-helpers.js';
 import { isSensitivePath } from '../path-policy.js';
-import { validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
+import { isPathWithinDirectories, normalizePath, validateExistingDirectory, validateExistingPathDetailed, } from '../path-validation.js';
 import { isIgnoredByGitignore, loadRootGitignore } from './gitignore.js';
 import { globEntries } from './glob-engine.js';
 function normalizeOptions(options) {
@@ -79,16 +79,27 @@ function getStopReason(signal, totalEntries, maxEntries) {
     return undefined;
 }
 async function resolveTreeEntry(entry, root, gitignoreMatcher, signal) {
-    try {
-        const validated = await validateExistingPathDetailed(entry.path, signal);
-        if (isSensitivePath(validated.requestedPath, validated.resolvedPath)) {
+    const type = resolveEntryType(entry.dirent);
+    if (type !== 'symlink') {
+        const normalized = normalizePath(entry.path);
+        if (!isPathWithinDirectories(normalized, [root])) {
+            return null;
+        }
+        if (isSensitivePath(entry.path, normalized)) {
             return null;
         }
     }
-    catch {
-        return null;
+    else {
+        try {
+            const validated = await validateExistingPathDetailed(entry.path, signal);
+            if (isSensitivePath(validated.requestedPath, validated.resolvedPath)) {
+                return null;
+            }
+        }
+        catch {
+            return null;
+        }
     }
-    const type = resolveEntryType(entry.dirent);
     if (gitignoreMatcher &&
         isIgnoredByGitignore(gitignoreMatcher, root, entry.path, {
             isDirectory: type === 'directory',
@@ -194,4 +205,3 @@ export async function treeDirectory(dirPath, options = {}) {
         cleanup();
     }
 }
-//# sourceMappingURL=tree.js.map

package/dist/lib/fs-helpers.d.ts

@@ -44,4 +44,3 @@ declare function headFile(handle: fsp.FileHandle, numLines: number, encoding?: B
 export declare function readFileWithStats(filePath: string, validPath: string, stats: Stats, options?: ReadFileOptions): Promise<ReadFileResult>;
 export declare function readFile(filePath: string, options?: ReadFileOptions): Promise<ReadFileResult>;
 export { headFile };
-//# sourceMappingURL=fs-helpers.d.ts.map

package/dist/lib/fs-helpers.js

@@ -15,24 +15,21 @@ export function assertNotAborted(signal, message) {
     if (!signal?.aborted)
         return;
     const { reason } = signal;
-    if (reason instanceof Error) {
+    if (reason instanceof Error)
         throw reason;
-    }
     throw createAbortError(message);
 }
 function getAbortError(signal, message) {
     const { reason } = signal;
-    if (reason instanceof Error) {
+    if (reason instanceof Error)
         return reason;
-    }
     return createAbortError(message);
 }
 export function withAbort(promise, signal) {
     if (!signal)
         return promise;
-    if (signal.aborted) {
+    if (signal.aborted)
         throw getAbortError(signal);
-    }
     return new Promise((resolve, reject) => {
         const onAbort = () => {
             reject(getAbortError(signal));
@@ -56,9 +53,6 @@ export function createTimedAbortSignal(baseSignal, timeoutMs) {
     if (!timeoutMs && baseSignal) {
         return createForwardedSignal(baseSignal);
     }
-    if (typeof timeoutMs === 'number' && shouldUseAbortAny(baseSignal)) {
-        return createAnySignal(baseSignal, timeoutMs);
-    }
     return createManualSignal(baseSignal, timeoutMs);
 }
 function createNoopSignal() {
@@ -68,19 +62,10 @@ function createNoopSignal() {
 function createForwardedSignal(baseSignal) {
     return { signal: baseSignal, cleanup: () => { } };
 }
-function shouldUseAbortAny(baseSignal) {
-    return typeof AbortSignal.any === 'function' && baseSignal !== undefined;
-}
-function createAnySignal(baseSignal, timeoutMs) {
-    const timeoutSignal = AbortSignal.timeout(timeoutMs);
-    const combined = AbortSignal.any([baseSignal, timeoutSignal]);
-    return { signal: combined, cleanup: () => { } };
-}
 function createManualSignal(baseSignal, timeoutMs) {
     const controller = new AbortController();
     const forwardAbort = () => {
-        const reason = baseSignal?.reason instanceof Error ? baseSignal.reason : undefined;
-        controller.abort(reason);
+        controller.abort(baseSignal?.reason);
     };
     if (baseSignal) {
         if (baseSignal.aborted) {
@@ -105,9 +90,11 @@ function createTimeout(controller, timeoutMs) {
     if (typeof timeoutMs !== 'number' || !Number.isFinite(timeoutMs)) {
         return undefined;
     }
-    return setTimeout(() => {
+    const timeoutId = setTimeout(() => {
         controller.abort(createAbortError('Operation timed out'));
     }, timeoutMs);
+    timeoutId.unref?.();
+    return timeoutId;
 }
 function createParallelAbortError() {
     return createAbortError();
@@ -137,15 +124,20 @@ function attachAbortListener(state, signal) {
 }
 function createAbortPromise(signal) {
     if (!signal)
-        return undefined;
+        return { cleanup: () => { } };
     if (signal.aborted)
-        return Promise.resolve();
-    return new Promise((resolve) => {
+        return { abortPromise: Promise.resolve(), cleanup: () => { } };
+    let cleanup = () => { };
+    const abortPromise = new Promise((resolve) => {
         const onAbort = () => {
             resolve();
         };
         signal.addEventListener('abort', onAbort, { once: true });
+        cleanup = () => {
+            signal.removeEventListener('abort', onAbort);
+        };
     });
+    return { abortPromise, cleanup };
 }
 function canStartNext(state) {
     return (!state.aborted &&
@@ -195,8 +187,9 @@ async function drainTasks(state, abortPromise) {
 }
 export async function processInParallel(items, processor, concurrency = PARALLEL_CONCURRENCY, signal) {
     const state = createState(items, processor, concurrency, signal);
-    const abortPromise = createAbortPromise(signal);
+    const { abortPromise, cleanup: cleanupAbortPromise } = createAbortPromise(signal);
     if (items.length === 0) {
+        cleanupAbortPromise();
         return { results: state.results, errors: state.errors };
     }
     const detachAbort = attachAbortListener(state, signal);
@@ -205,6 +198,7 @@ export async function processInParallel(items, processor, concurrency = PARALLEL
     }
     finally {
         detachAbort();
+        cleanupAbortPromise();
     }
     if (state.aborted) {
         throw createParallelAbortError();
@@ -441,6 +435,7 @@ async function readRangeContent(handle, startLine, endLine, options) {
             continue;
         }
         if (lineNumber > stopAt) {
+            hasMoreLines = true;
             stoppedEarly = true;
             break;
         }
@@ -598,4 +593,3 @@ export async function readFile(filePath, options = {}) {
     return await readFileWithStatsInternal(filePath, validPath, stats, normalized);
 }
 export { headFile };
-//# sourceMappingURL=fs-helpers.js.map

package/dist/lib/observability.d.ts

@@ -12,4 +12,3 @@ export declare function publishOpsTraceError(context: OpsTraceContext, error: un
 export declare function withToolDiagnostics<T>(tool: string, run: () => Promise<T>, options?: {
     path?: string;
 }): Promise<T>;
-//# sourceMappingURL=observability.d.ts.map

package/dist/lib/observability.js

@@ -22,9 +22,8 @@ function resolveDiagnosticsOk(result) {
 function resolvePrimitiveDiagnosticsMessage(error) {
     if (typeof error === 'string')
         return error;
-    if (typeof error === 'number' || typeof error === 'boolean') {
+    if (typeof error === 'number' || typeof error === 'boolean')
         return String(error);
-    }
     if (typeof error === 'bigint')
         return error.toString();
     if (typeof error === 'symbol')
@@ -73,15 +72,19 @@ function captureEventLoopUtilization() {
 function diffEventLoopUtilization(start) {
     return performance.eventLoopUtilization(start);
 }
+function elapsedMs(startNs) {
+    return Number(process.hrtime.bigint() - startNs) / 1_000_000;
+}
 const TOOL_CHANNEL = channel('fs-context:tool');
 const PERF_CHANNEL = channel('fs-context:perf');
 const OPS_TRACE = tracingChannel('fs-context:ops');
-function parseDiagnosticsEnabled() {
-    const normalized = process.env['FS_CONTEXT_DIAGNOSTICS']
-        ?.trim()
-        .toLowerCase();
+function parseEnvBoolean(name) {
+    const normalized = process.env[name]?.trim().toLowerCase();
     return normalized === '1' || normalized === 'true' || normalized === 'yes';
 }
+function parseDiagnosticsEnabled() {
+    return parseEnvBoolean('FS_CONTEXT_DIAGNOSTICS');
+}
 function parseDiagnosticsDetail() {
     const normalized = process.env['FS_CONTEXT_DIAGNOSTICS_DETAIL']?.trim();
     if (normalized === '2')
@@ -91,16 +94,19 @@ function parseDiagnosticsDetail() {
     return 0;
 }
 function parseToolErrorLogging() {
-    const normalized = process.env['FS_CONTEXT_TOOL_LOG_ERRORS']
-        ?.trim()
-        .toLowerCase();
-    return normalized === '1' || normalized === 'true' || normalized === 'yes';
+    return parseEnvBoolean('FS_CONTEXT_TOOL_LOG_ERRORS');
+}
+function readDiagnosticsConfig() {
+    return {
+        enabled: parseDiagnosticsEnabled(),
+        detail: parseDiagnosticsDetail(),
+        logToolErrors: parseToolErrorLogging(),
+    };
 }
 function hashPath(value) {
     return createHash('sha256').update(value).digest('hex').slice(0, 16);
 }
-function normalizePathForDiagnostics(pathValue) {
-    const detail = parseDiagnosticsDetail();
+function normalizePathForDiagnostics(pathValue, detail) {
     if (detail === 0)
         return undefined;
     if (detail === 2)
@@ -110,7 +116,8 @@ function normalizePathForDiagnostics(pathValue) {
 function normalizeOpsTraceContext(context) {
     if (!context.path)
         return context;
-    const normalizedPath = normalizePathForDiagnostics(context.path);
+    const detail = parseDiagnosticsDetail();
+    const normalizedPath = normalizePathForDiagnostics(context.path, detail);
     if (!normalizedPath) {
         const sanitized = { ...context };
         delete sanitized.path;
@@ -118,10 +125,10 @@ function normalizeOpsTraceContext(context) {
     }
     return { ...context, path: normalizedPath };
 }
-function publishStartEvent(tool, options) {
+function publishStartEvent(tool, options, detail) {
     const event = { phase: 'start', tool };
     const normalizedPath = options?.path
-        ? normalizePathForDiagnostics(options.path)
+        ? normalizePathForDiagnostics(options.path, detail)
         : undefined;
     if (normalizedPath !== undefined) {
         event.path = normalizedPath;
@@ -153,18 +160,18 @@ function publishPerfEndEvent(tool, durationMs, elu) {
         },
     });
 }
-function startToolDiagnostics(tool, options, shouldPublishTool, shouldPublishPerf) {
+function startToolDiagnostics(tool, options, config, shouldPublishTool, shouldPublishPerf) {
     const startNs = process.hrtime.bigint();
     const eluStart = shouldPublishPerf
         ? captureEventLoopUtilization()
         : undefined;
-    if (shouldPublishTool)
-        publishStartEvent(tool, options);
+    if (shouldPublishTool) {
+        publishStartEvent(tool, options, config.detail);
+    }
     return { startNs, eluStart };
 }
 function finalizeToolDiagnostics(tool, startNs, options) {
-    const endNs = process.hrtime.bigint();
-    const durationMs = Number(endNs - startNs) / 1_000_000;
+    const durationMs = elapsedMs(startNs);
     if (options.shouldPublishPerf && options.eluStart) {
         publishPerfEndEvent(tool, durationMs, diffEventLoopUtilization(options.eluStart));
     }
@@ -172,8 +179,8 @@ function finalizeToolDiagnostics(tool, startNs, options) {
         publishEndEvent(tool, options.ok, durationMs, options.error);
     }
 }
-async function runWithDiagnostics(tool, run, options, shouldPublishTool, shouldPublishPerf) {
-    const { startNs, eluStart } = startToolDiagnostics(tool, options, shouldPublishTool, shouldPublishPerf);
+async function runWithDiagnostics(tool, run, options, config, shouldPublishTool, shouldPublishPerf) {
+    const { startNs, eluStart } = startToolDiagnostics(tool, options, config, shouldPublishTool, shouldPublishPerf);
     const finalizeOptions = { shouldPublishTool, shouldPublishPerf, eluStart };
     try {
         const result = await run();
@@ -192,6 +199,21 @@ async function runWithDiagnostics(tool, run, options, shouldPublishTool, shouldP
         throw error;
     }
 }
+async function runWithErrorLogging(tool, run) {
+    const startNs = process.hrtime.bigint();
+    try {
+        const result = await run();
+        const ok = resolveDiagnosticsOk(result);
+        if (ok === false) {
+            logToolError(tool, elapsedMs(startNs), resolveResultErrorMessage(result));
+        }
+        return result;
+    }
+    catch (error) {
+        logToolError(tool, elapsedMs(startNs), resolveDiagnosticsErrorMessage(error));
+        throw error;
+    }
+}
 export function shouldPublishOpsTrace() {
     return parseDiagnosticsEnabled() && OPS_TRACE.hasSubscribers;
 }
@@ -208,32 +230,16 @@ export function publishOpsTraceError(context, error) {
     });
 }
 export async function withToolDiagnostics(tool, run, options) {
-    const shouldLogErrors = parseToolErrorLogging();
-    if (!parseDiagnosticsEnabled()) {
-        if (!shouldLogErrors) {
+    const config = readDiagnosticsConfig();
+    if (!config.enabled) {
+        if (!config.logToolErrors)
             return await run();
-        }
-        const startNs = process.hrtime.bigint();
-        try {
-            const result = await run();
-            const ok = resolveDiagnosticsOk(result);
-            if (ok === false) {
-                const durationMs = Number(process.hrtime.bigint() - startNs) / 1_000_000;
-                logToolError(tool, durationMs, resolveResultErrorMessage(result));
-            }
-            return result;
-        }
-        catch (error) {
-            const durationMs = Number(process.hrtime.bigint() - startNs) / 1_000_000;
-            logToolError(tool, durationMs, resolveDiagnosticsErrorMessage(error));
-            throw error;
-        }
+        return await runWithErrorLogging(tool, run);
     }
     const shouldPublishTool = TOOL_CHANNEL.hasSubscribers;
     const shouldPublishPerf = PERF_CHANNEL.hasSubscribers;
     if (!shouldPublishTool && !shouldPublishPerf) {
         return await run();
     }
-    return await runWithDiagnostics(tool, run, options, shouldPublishTool, shouldPublishPerf);
+    return await runWithDiagnostics(tool, run, options, config, shouldPublishTool, shouldPublishPerf);
 }
-//# sourceMappingURL=observability.js.map

package/dist/lib/path-policy.d.ts

@@ -1,3 +1,2 @@
 export declare function isSensitivePath(requestedPath: string, resolvedPath?: string): boolean;
 export declare function assertAllowedFileAccess(requestedPath: string, resolvedPath?: string): void;
-//# sourceMappingURL=path-policy.d.ts.map

package/dist/lib/path-policy.js

@@ -66,4 +66,3 @@ export function assertAllowedFileAccess(requestedPath, resolvedPath) {
     throw new McpError(ErrorCode.E_ACCESS_DENIED, `Access denied: sensitive file blocked by policy (${requestedPath}). ` +
         'Set FS_CONTEXT_ALLOW_SENSITIVE=1 or use FS_CONTEXT_ALLOWLIST to override.', requestedPath);
 }
-//# sourceMappingURL=path-policy.js.map

package/dist/lib/path-validation.d.ts

@@ -18,4 +18,3 @@ export declare function validateExistingPath(requestedPath: string, signal?: Abo
 export declare function validateExistingDirectory(requestedPath: string, signal?: AbortSignal): Promise<string>;
 export declare function getValidRootDirectories(roots: Root[], signal?: AbortSignal): Promise<string[]>;
 export {};
-//# sourceMappingURL=path-validation.d.ts.map