@j0hanz/filesystem-mcp 1.11.0 → 1.12.0

package/dist/tools/task-support.js

@@ -1,11 +1,22 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { channel } from 'node:diagnostics_channel';
+import { performance } from 'node:perf_hooks';
+import { format } from 'node:util';
 import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
-import { DEFAULT_TASK_TTL_MS } from '../lib/constants.js';
+import { DEFAULT_TASK_TTL_MS, MAX_CONCURRENT_TASKS, MAX_TASK_TTL_MS, } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { isRecord } from '../lib/utils.js';
 import { buildToolErrorResponse, maybeStripStructuredContentFromResult, withDefaultIcons, } from './shared.js';
+export const taskContext = new AsyncLocalStorage();
+const TASK_DIAGNOSTICS_CHANNEL = channel('filesystem-mcp:tasks');
+function publishTaskDiagnostics(event) {
+    if (TASK_DIAGNOSTICS_CHANNEL.hasSubscribers) {
+        TASK_DIAGNOSTICS_CHANNEL.publish(event);
+    }
+}
+// --- Type Guards & Helpers ---
 function isExperimentalTaskRegistration(value) {
-    if (!value || typeof value !== 'object')
+    if (!isRecord(value))
         return false;
     const { registerToolTask } = value;
     return (registerToolTask === undefined || typeof registerToolTask === 'function');
@@ -13,7 +24,7 @@ function isExperimentalTaskRegistration(value) {
 function getExperimentalTaskRegistration(server) {
     const serverWithExperimental = server;
     const { experimental } = serverWithExperimental;
-    if (!experimental || typeof experimental !== 'object')
+    if (!isRecord(experimental))
         return undefined;
     const { tasks } = experimental;
     if (!isExperimentalTaskRegistration(tasks))
@@ -24,49 +35,34 @@ function hasTaskToolCapability(server) {
     const serverRecord = server;
     const { server: serverRuntime } = serverRecord;
     if (!isRecord(serverRuntime))
-        return true;
+        return true; // Assume capability if runtime structure is opaque
     const { getCapabilities } = serverRuntime;
-    if (typeof getCapabilities !== 'function') {
-        // Fallback for tests or custom wrappers that provide only registerTool/experimental.
+    if (typeof getCapabilities !== 'function')
         return true;
-    }
     const capabilities = getCapabilities.call(serverRuntime);
     if (!isRecord(capabilities))
         return false;
     const { tasks } = capabilities;
-    if (!isRecord(tasks))
-        return false;
-    const { requests } = tasks;
-    if (!isRecord(requests))
-        return false;
-    const { tools } = requests;
-    if (!isRecord(tools))
-        return false;
-    const { call } = tools;
-    return isRecord(call);
+    return (isRecord(tasks) &&
+        isRecord(tasks.requests) &&
+        isRecord(tasks.requests.tools) &&
+        isRecord(tasks.requests.tools.call));
 }
 const TASK_STATUS_NOTIFICATION_METHOD = 'notifications/tasks/status';
-const TASK_DIAGNOSTICS_CHANNEL = channel('filesystem-mcp:tasks');
-function publishTaskDiagnostics(event) {
-    if (!TASK_DIAGNOSTICS_CHANNEL.hasSubscribers)
-        return;
-    TASK_DIAGNOSTICS_CHANNEL.publish(event);
-}
 function isRequestTaskStore(value) {
-    if (!isRecord(value))
-        return false;
-    return (typeof value['createTask'] === 'function' &&
-        typeof value['getTask'] === 'function' &&
-        typeof value['storeTaskResult'] === 'function' &&
-        typeof value['getTaskResult'] === 'function');
+    return (isRecord(value) &&
+        typeof value.createTask === 'function' &&
+        typeof value.getTask === 'function' &&
+        typeof value.storeTaskResult === 'function' &&
+        typeof value.getTaskResult === 'function');
 }
 function isCreateTaskExtra(value) {
-    return isRecord(value) && isRequestTaskStore(value['taskStore']);
+    return isRecord(value) && isRequestTaskStore(value.taskStore);
 }
 function isTaskExtra(value) {
     return (isCreateTaskExtra(value) &&
-        typeof value['taskId'] === 'string' &&
-        value['taskId'].length > 0);
+        typeof value.taskId === 'string' &&
+        value.taskId.length > 0);
 }
 function asCreateTaskExtra(value) {
     if (!isCreateTaskExtra(value)) {
@@ -91,39 +87,34 @@ function isTaskStatus(value) {
     return (typeof value === 'string' &&
         TASK_STATUSES.has(value));
 }
-function parseTaskStatus(value) {
-    return isTaskStatus(value) ? value : undefined;
-}
 function normalizeGetTaskResult(value) {
-    if (!isRecord(value) || typeof value['taskId'] !== 'string') {
+    if (!isRecord(value) || typeof value.taskId !== 'string') {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'Invalid task object.');
     }
-    const status = parseTaskStatus(value['status']);
+    const status = isTaskStatus(value.status) ? value.status : undefined;
     if (!status) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'Invalid task status.');
     }
-    const createdAt = typeof value['createdAt'] === 'string'
-        ? value['createdAt']
+    const createdAt = typeof value.createdAt === 'string'
+        ? value.createdAt
         : new Date().toISOString();
-    const lastUpdatedAt = typeof value['lastUpdatedAt'] === 'string'
-        ? value['lastUpdatedAt']
-        : createdAt;
-    const ttl = typeof value['ttl'] === 'number' ? value['ttl'] : null;
+    const lastUpdatedAt = typeof value.lastUpdatedAt === 'string' ? value.lastUpdatedAt : createdAt;
+    const ttl = typeof value.ttl === 'number' ? value.ttl : null;
     const normalized = {
-        taskId: value['taskId'],
+        taskId: value.taskId,
         status,
         ttl,
         createdAt,
         lastUpdatedAt,
     };
-    if (typeof value['pollInterval'] === 'number') {
-        normalized.pollInterval = value['pollInterval'];
+    if (typeof value.pollInterval === 'number') {
+        normalized.pollInterval = value.pollInterval;
     }
-    if (typeof value['statusMessage'] === 'string') {
-        normalized.statusMessage = value['statusMessage'];
+    if (typeof value.statusMessage === 'string') {
+        normalized.statusMessage = value.statusMessage;
     }
-    if (isRecord(value['_meta'])) {
-        normalized._meta = value['_meta'];
+    if (isRecord(value._meta)) {
+        normalized._meta = value._meta;
     }
     return normalized;
 }
@@ -134,17 +125,15 @@ function normalizeCallToolResult(value) {
     throw new McpError(ErrorCode.E_INVALID_INPUT, 'Stored task result is not a valid tool result.');
 }
 function getToolResultErrorCode(result) {
-    if (!isRecord(result) || result['isError'] !== true)
+    if (!isRecord(result) || result.isError !== true)
         return undefined;
-    // First check for a dedicated errorCode property to avoid regex parsing of the content for structured error results produced by newer code.
-    if (typeof result['errorCode'] === 'string')
-        return result['errorCode'];
-    // Fallback to regex parsing of the human-readable error message for older error results that lack a structured errorCode property.
+    if (typeof result.errorCode === 'string')
+        return result.errorCode;
     const { content } = result;
     if (!Array.isArray(content) || content.length === 0)
         return undefined;
     const first = content[0];
-    if (!isRecord(first) || first['type'] !== 'text')
+    if (!isRecord(first) || first.type !== 'text')
         return undefined;
     const { text } = first;
     if (typeof text !== 'string')
@@ -155,6 +144,25 @@ function getToolResultErrorCode(result) {
 function isCancelledToolResult(result) {
     return getToolResultErrorCode(result) === ErrorCode.E_CANCELLED;
 }
+function resolveTaskResultStatuses(result) {
+    if (isCancelledToolResult(result)) {
+        return { storedStatus: 'failed', reportedStatus: 'cancelled' };
+    }
+    if (isRecord(result) && result.isError === true) {
+        return { storedStatus: 'failed', reportedStatus: 'failed' };
+    }
+    return { storedStatus: 'completed', reportedStatus: 'completed' };
+}
+function attachRelatedTaskMeta(result, taskId) {
+    const existingMeta = isRecord(result._meta) ? result._meta : {};
+    return {
+        ...result,
+        _meta: {
+            ...existingMeta,
+            'io.modelcontextprotocol/related-task': { taskId },
+        },
+    };
+}
 async function projectCancelledTaskStatus(taskStore, task) {
     if (task.status !== 'failed')
         return task;
@@ -199,14 +207,14 @@ async function notifyTaskStatusIfPossible(extra, taskStore, taskId, toolName) {
             phase: 'task_status_notified',
             taskId,
             status: normalized.status,
-            ...(toolName !== undefined ? { toolName } : {}),
+            ...(toolName ? { toolName } : {}),
         });
     }
     catch {
         publishTaskDiagnostics({
             phase: 'task_status_notify_failed',
             taskId,
-            ...(toolName !== undefined ? { toolName } : {}),
+            ...(toolName ? { toolName } : {}),
         });
         // Never fail task execution because status notifications are optional.
     }
@@ -226,7 +234,7 @@ function getTaskId(extra) {
 function isErrorResult(result) {
     return 'isError' in result && result.isError;
 }
-// Strips structuredContent from a tool result if present, without modifying the original object.  This is used when storing error results as 'completed' to prevent client-side output schema validation errors, while still allowing the human-readable error message in content[0].text to be returned to clients.
+// Strips structuredContent from a tool result if present, without modifying the original object.
 function withoutStructuredContent(result) {
     if (!Object.hasOwn(result, 'structuredContent'))
         return result;
@@ -251,61 +259,89 @@ async function isTaskAlreadyTerminal(taskStore, taskId) {
         return false;
     }
 }
-async function tryStoreTaskResult(taskStore, taskId, status, result) {
+async function countActiveTasks(taskStore) {
+    if (typeof taskStore.listTasks !== 'function')
+        return 0;
+    const listed = await taskStore.listTasks();
+    const tasks = Array.isArray(listed.tasks) ? listed.tasks : [];
+    let active = 0;
+    for (const task of tasks) {
+        if (!isRecord(task) || typeof task.status !== 'string')
+            continue;
+        if (task.status !== 'completed' &&
+            task.status !== 'failed' &&
+            task.status !== 'cancelled') {
+            active += 1;
+        }
+    }
+    return active;
+}
+function resolveRequestedTaskTtl(requestedTtl) {
+    if (requestedTtl == null)
+        return DEFAULT_TASK_TTL_MS;
+    if (!Number.isFinite(requestedTtl)) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Task ttl must be a finite number of milliseconds.');
+    }
+    const normalized = Math.trunc(requestedTtl);
+    if (normalized <= 0) {
+        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Task ttl must be greater than zero.');
+    }
+    return Math.min(normalized, MAX_TASK_TTL_MS);
+}
+async function safelyStoreTaskResult(taskStore, taskId, storedStatus, result) {
     try {
-        await taskStore.storeTaskResult(taskId, status, result);
+        await taskStore.storeTaskResult(taskId, storedStatus, result);
     }
     catch (error) {
+        // If task was already cancelled/failed by another process, ignore the write error
         if (await isTaskAlreadyTerminal(taskStore, taskId))
             return;
         throw error;
     }
 }
 async function runTaskInBackground(run, args, extra, taskStore, taskId, toolName) {
+    const start = performance.now();
+    let taskStatuses;
+    let result;
     try {
-        const rawResult = await run(args, extra);
-        const status = isCancelledToolResult(rawResult) ? 'failed' : 'completed';
-        const result = isErrorResult(rawResult) && status === 'completed'
+        const rawResult = await taskContext.run({ taskId, toolName, startTime: start }, () => run(args, extra));
+        taskStatuses = resolveTaskResultStatuses(rawResult);
+        result = isErrorResult(rawResult)
             ? withoutStructuredContent(rawResult)
             : maybeStripStructuredContentFromResult(rawResult);
-        await tryStoreTaskResult(taskStore, taskId, status, result);
+    }
+    catch (error) {
+        taskStatuses = { storedStatus: 'failed', reportedStatus: 'failed' };
+        result = maybeStripStructuredContentFromResult(buildToolErrorResponse(error, ErrorCode.E_UNKNOWN));
+    }
+    const durationMs = performance.now() - start;
+    try {
+        await safelyStoreTaskResult(taskStore, taskId, taskStatuses.storedStatus, result);
         publishTaskDiagnostics({
             phase: 'task_result_stored',
             taskId,
-            status,
-            ...(toolName !== undefined ? { toolName } : {}),
+            status: taskStatuses.reportedStatus,
+            toolName,
+            durationMs,
         });
         await notifyTaskStatusIfPossible(extra, taskStore, taskId, toolName);
     }
-    catch (error) {
-        const fallback = maybeStripStructuredContentFromResult(buildToolErrorResponse(error, ErrorCode.E_UNKNOWN));
-        try {
-            await tryStoreTaskResult(taskStore, taskId, 'failed', fallback);
-            publishTaskDiagnostics({
-                phase: 'task_result_stored',
-                taskId,
-                status: 'failed',
-                ...(toolName !== undefined ? { toolName } : {}),
+    catch (innerError) {
+        console.error(format('Failed to store task result for task %s:', taskId), innerError);
+        const syntheticTask = {
+            taskId,
+            status: taskStatuses.reportedStatus === 'cancelled' ? 'cancelled' : 'failed',
+            ttl: null,
+            createdAt: new Date().toISOString(),
+            lastUpdatedAt: new Date().toISOString(),
+            statusMessage: 'Internal system error while storing result',
+        };
+        const { sendNotification } = extra;
+        if (typeof sendNotification === 'function') {
+            void sendNotification({
+                method: TASK_STATUS_NOTIFICATION_METHOD,
+                params: buildTaskStatusNotificationParams(syntheticTask),
             });
-            await notifyTaskStatusIfPossible(extra, taskStore, taskId, toolName);
-        }
-        catch (innerError) {
-            console.error(`Failed to store task failure result for task ${taskId}:`, innerError);
-            // If storing the failure result also fails, there's not much we can do. The task will remain in 'working' status until it expires, which is not ideal but at least prevents clients from receiving incorrect results or hanging indefinitely waiting for a result that will never arrive. We log the error to aid debugging, and we attempt to notify the client of the failure if possible, but we don't want to throw further errors that could crash the server or cause cascading failures.
-            const syntheticTask = {
-                taskId,
-                status: 'failed',
-                ttl: null,
-                createdAt: new Date().toISOString(),
-                lastUpdatedAt: new Date().toISOString(),
-            };
-            const { sendNotification } = extra;
-            if (typeof sendNotification === 'function') {
-                void sendNotification({
-                    method: TASK_STATUS_NOTIFICATION_METHOD,
-                    params: buildTaskStatusNotificationParams(syntheticTask),
-                });
-            }
         }
     }
 }
@@ -324,7 +360,9 @@ function tryRegisterToolTask(server, toolName, toolDef, taskHandler, iconInfo) {
     const existingExecution = def.execution ?? {};
     const taskSupport = def.taskSupport ??
         existingExecution.taskSupport ??
-        'optional';
+        'forbidden';
+    if (taskSupport === 'forbidden')
+        return false;
     tasks.registerToolTask(toolName, withDefaultIcons({ ...toolDef, execution: { ...existingExecution, taskSupport } }, iconInfo), taskHandler);
     return true;
 }
@@ -343,16 +381,17 @@ export function createToolTaskHandler(run, options) {
             throw new McpError(ErrorCode.E_INVALID_INPUT, 'Client not initialized; wait for notifications/initialized');
         }
         const taskStore = getTaskStore(extra);
+        if ((await countActiveTasks(taskStore)) >= MAX_CONCURRENT_TASKS) {
+            throw new McpError(ErrorCode.E_INVALID_INPUT, `Too many active tasks. Limit: ${String(MAX_CONCURRENT_TASKS)}.`);
+        }
         const task = await taskStore.createTask({
-            ttl: extra.taskRequestedTtl ?? DEFAULT_TASK_TTL_MS,
+            ttl: resolveRequestedTaskTtl(extra.taskRequestedTtl),
         });
         publishTaskDiagnostics({
             phase: 'task_created',
             taskId: task.taskId,
             status: task.status,
-            ...(options?.toolName !== undefined
-                ? { toolName: options.toolName }
-                : {}),
+            ...(options?.toolName ? { toolName: options.toolName } : {}),
         });
         const taskExtra = {
             ...extra,
@@ -375,7 +414,7 @@ export function createToolTaskHandler(run, options) {
         const taskStore = getTaskStore(extra);
         const taskId = getTaskId(extra);
         const result = await taskStore.getTaskResult(taskId);
-        return normalizeCallToolResult(result);
+        return attachRelatedTaskMeta(normalizeCallToolResult(result), taskId);
     });
     return {
         createTask,

package/dist/tools/write-file.js

@@ -17,18 +17,18 @@ export const WRITE_FILE_TOOL = {
     gotchas: [
         '`write` replaces ALL existing content — use `edit` for partial updates.',
     ],
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
 };
 async function handleWriteFile(args, signal) {
     const validPath = await validatePathForWrite(args.path, signal);
     // Ensure parent directory exists
     await withAbort(fs.mkdir(path.dirname(validPath), { recursive: true }), signal);
     await atomicWriteFile(validPath, args.content, { encoding: 'utf-8', signal });
-    const stats = await withAbort(fs.stat(validPath), signal);
+    const bytesWritten = Buffer.byteLength(args.content, 'utf-8');
     return buildToolResponse(`Successfully wrote to file: ${args.path}`, {
         ok: true,
         path: validPath,
-        bytesWritten: stats.size,
+        bytesWritten,
     });
 }
 export function registerWriteFileTool(server, options = {}) {
@@ -50,7 +50,7 @@ export function registerWriteFileTool(server, options = {}) {
             const sc = result.structuredContent;
             if (!sc.ok)
                 return `🛠 write: ${name} • failed`;
-            return `🛠 write: ${name} • ${formatBytes(sc.bytesWritten ?? 0)} written`;
+            return `🛠 write: ${name} • ${formatBytes(sc.bytesWritten ?? 0)}`;
         },
     });
     const validatedHandler = withValidatedArgs(WriteFileInputSchema, wrappedHandler);

package/dist/tools.js

@@ -7,7 +7,7 @@ import { DIFF_FILES_TOOL, registerDiffFilesTool } from './tools/diff-files.js';
 import { EDIT_FILE_TOOL, registerEditFileTool } from './tools/edit-file.js';
 import { LIST_DIRECTORY_TOOL, registerListDirectoryTool, } from './tools/list-directory.js';
 import { MOVE_FILE_TOOL, registerMoveFileTool } from './tools/move-file.js';
-import { READ_MULTIPLE_FILES_TOOL, registerReadMultipleFilesTool, } from './tools/read-multiple.js';
+import { READ_MANY_TOOL, registerReadMultipleFilesTool, } from './tools/read-multiple.js';
 import { READ_FILE_TOOL, registerReadFileTool } from './tools/read.js';
 import { registerSearchAndReplaceTool, SEARCH_AND_REPLACE_TOOL, } from './tools/replace-in-files.js';
 import { LIST_ALLOWED_DIRECTORIES_TOOL, registerListAllowedDirectoriesTool, } from './tools/roots.js';
@@ -28,7 +28,7 @@ const TOOL_ENTRIES = [
     { contract: TREE_TOOL, register: registerTreeTool },
     { contract: READ_FILE_TOOL, register: registerReadFileTool },
     {
-        contract: READ_MULTIPLE_FILES_TOOL,
+        contract: READ_MANY_TOOL,
         register: registerReadMultipleFilesTool,
     },
     { contract: GET_FILE_INFO_TOOL, register: registerGetFileInfoTool },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "A local filesystem MCP server that lets LLMs and AI agents read, write, search, diff, patch, and manage files safely and efficiently. Built for reliable, structured, and controlled filesystem interaction.",
   "type": "module",