@j0hanz/filesystem-mcp 1.14.0 → 1.14.1

package/dist/tools/task-support.js

@@ -1,10 +1,11 @@
+import { CallToolResultSchema, } from '@modelcontextprotocol/sdk/types.js';
 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, MAX_CONCURRENT_TASKS, MAX_TASK_TTL_MS, } from '../lib/constants.js';
+import { DEFAULT_TASK_TTL_MS, MAX_CONCURRENT_TASKS, MAX_TASK_TTL_MS, TASK_CANCEL_POLL_MS, TASK_POLL_INTERVAL_MS, } from '../lib/constants.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
+import { Logger } from '../lib/logger.js';
 import { isRecord } from '../lib/utils.js';
 import { buildToolErrorResponse, maybeStripStructuredContentFromResult, withDefaultIcons, } from './shared.js';
 const taskContext = new AsyncLocalStorage();
@@ -50,6 +51,7 @@ function hasTaskToolCapability(server) {
         isRecord(tasks.requests.tools.call));
 }
 const TASK_STATUS_NOTIFICATION_METHOD = 'notifications/tasks/status';
+const TASK_CREATED_NOTIFICATION_METHOD = 'notifications/tasks/created';
 function isRequestTaskStore(value) {
     return (isRecord(value) &&
         typeof value.createTask === 'function' &&
@@ -67,13 +69,13 @@ function isTaskExtra(value) {
 }
 function asCreateTaskExtra(value) {
     if (!isCreateTaskExtra(value)) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Task store not configured for task-capable tool.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Task store not configured.');
     }
     return value;
 }
 function asTaskRequestExtra(value) {
     if (!isTaskExtra(value)) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Task id or task store missing for task operation.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Task id or store missing.');
     }
     return value;
 }
@@ -90,11 +92,11 @@ function isTaskStatus(value) {
 }
 function normalizeGetTaskResult(value) {
     if (!isRecord(value) || typeof value.taskId !== 'string') {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Invalid task object.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Invalid task object.');
     }
     const status = isTaskStatus(value.status) ? value.status : undefined;
     if (!status) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Invalid task status.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Invalid task status.');
     }
     const createdAt = typeof value.createdAt === 'string'
         ? value.createdAt
@@ -123,7 +125,7 @@ function normalizeCallToolResult(value) {
     const parsed = CallToolResultSchema.safeParse(value);
     if (parsed.success)
         return parsed.data;
-    throw new McpError(ErrorCode.E_INVALID_INPUT, 'Stored task result is not a valid tool result.');
+    throw new McpError(ErrorCode.INVALID_INPUT, 'Invalid stored task result.');
 }
 function getToolResultErrorCode(result) {
     if (!isRecord(result) || result.isError !== true)
@@ -143,7 +145,7 @@ function getToolResultErrorCode(result) {
     return match ? match[1] : undefined;
 }
 function isCancelledToolResult(result) {
-    return getToolResultErrorCode(result) === ErrorCode.E_CANCELLED;
+    return getToolResultErrorCode(result) === ErrorCode.CANCELLED;
 }
 function resolveTaskResultStatuses(result) {
     if (isCancelledToolResult(result)) {
@@ -192,6 +194,31 @@ function buildTaskStatusNotificationParams(task) {
         params.statusMessage = task.statusMessage;
     return params;
 }
+async function notifyTaskCreatedIfPossible(extra, taskId, toolName) {
+    const { sendNotification } = extra;
+    if (typeof sendNotification !== 'function')
+        return;
+    const notify = sendNotification;
+    try {
+        await notify({
+            method: TASK_CREATED_NOTIFICATION_METHOD,
+            params: {
+                _meta: {
+                    'modelcontextprotocol.io/related-task': {
+                        taskId,
+                    },
+                },
+            },
+        });
+    }
+    catch {
+        publishTaskDiagnostics({
+            phase: 'task_status_notify_failed',
+            taskId,
+            ...(toolName ? { toolName } : {}),
+        });
+    }
+}
 async function notifyTaskStatusIfPossible(extra, taskStore, taskId, toolName) {
     const { sendNotification } = extra;
     if (typeof sendNotification !== 'function')
@@ -222,13 +249,13 @@ async function notifyTaskStatusIfPossible(extra, taskStore, taskId, toolName) {
 }
 function getTaskStore(extra) {
     if (!extra.taskStore) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Task store not configured for task-capable tool.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Task store not configured.');
     }
     return extra.taskStore;
 }
 function getTaskId(extra) {
     if (!extra.taskId) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Task id missing for task operation.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Task id missing.');
     }
     return extra.taskId;
 }
@@ -260,6 +287,10 @@ async function isTaskAlreadyTerminal(taskStore, taskId) {
         return false;
     }
 }
+function isMissingTaskStoreError(error) {
+    return (error instanceof Error &&
+        /Task .*not found|not found after cancellation/iu.test(error.message));
+}
 async function countActiveTasks(taskStore) {
     if (typeof taskStore.listTasks !== 'function')
         return 0;
@@ -281,11 +312,11 @@ 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.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Task TTL must be finite.');
     }
     const normalized = Math.trunc(requestedTtl);
     if (normalized <= 0) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Task ttl must be greater than zero.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Task TTL must be > 0.');
     }
     return Math.min(normalized, MAX_TASK_TTL_MS);
 }
@@ -294,18 +325,40 @@ async function safelyStoreTaskResult(taskStore, taskId, storedStatus, result) {
         await taskStore.storeTaskResult(taskId, storedStatus, result);
     }
     catch (error) {
+        if (isMissingTaskStoreError(error))
+            return;
         // 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) {
+async function isTaskCancelled(taskStore, taskId) {
+    try {
+        const task = await taskStore.getTask(taskId);
+        return isRecord(task) && task.status === 'cancelled';
+    }
+    catch {
+        return false;
+    }
+}
+async function runTaskInBackground(run, args, extra, taskStore, taskId, toolName, cancelPollMs) {
+    // Create a dedicated AbortController for background execution.
+    // The original request signal is stale once createTask returns.
+    const taskAbort = new AbortController();
+    const taskExtra = { ...extra, signal: taskAbort.signal };
+    // Poll the task store for client-initiated cancellation.
+    const cancelPoller = setInterval(() => {
+        void isTaskCancelled(taskStore, taskId).then((cancelled) => {
+            if (cancelled)
+                taskAbort.abort(new Error('Task cancelled by client'));
+        });
+    }, cancelPollMs ?? TASK_CANCEL_POLL_MS);
     const start = performance.now();
     let taskStatuses;
     let result;
     try {
-        const rawResult = await taskContext.run({ taskId, toolName, startTime: start }, () => run(args, extra));
+        const rawResult = await taskContext.run({ taskId, toolName, startTime: start }, () => run(args, taskExtra));
         taskStatuses = resolveTaskResultStatuses(rawResult);
         result = isErrorResult(rawResult)
             ? withoutStructuredContent(rawResult)
@@ -313,7 +366,10 @@ async function runTaskInBackground(run, args, extra, taskStore, taskId, toolName
     }
     catch (error) {
         taskStatuses = { storedStatus: 'failed', reportedStatus: 'failed' };
-        result = maybeStripStructuredContentFromResult(buildToolErrorResponse(error, ErrorCode.E_UNKNOWN));
+        result = maybeStripStructuredContentFromResult(buildToolErrorResponse(error, ErrorCode.UNKNOWN));
+    }
+    finally {
+        clearInterval(cancelPoller);
     }
     const durationMs = performance.now() - start;
     try {
@@ -328,7 +384,7 @@ async function runTaskInBackground(run, args, extra, taskStore, taskId, toolName
         await notifyTaskStatusIfPossible(extra, taskStore, taskId, toolName);
     }
     catch (innerError) {
-        console.error(format('Failed to store task result for task %s:', taskId), innerError);
+        Logger.error(format('Failed to store task result for task %s:', taskId), innerError);
         const syntheticTask = {
             taskId,
             status: taskStatuses.reportedStatus === 'cancelled' ? 'cancelled' : 'failed',
@@ -339,10 +395,16 @@ async function runTaskInBackground(run, args, extra, taskStore, taskId, toolName
         };
         const { sendNotification } = extra;
         if (typeof sendNotification === 'function') {
-            void sendNotification({
-                method: TASK_STATUS_NOTIFICATION_METHOD,
-                params: buildTaskStatusNotificationParams(syntheticTask),
-            });
+            try {
+                await sendNotification({
+                    method: TASK_STATUS_NOTIFICATION_METHOD,
+                    params: buildTaskStatusNotificationParams(syntheticTask),
+                });
+            }
+            catch {
+                // Best effort only: transport may already be closed while a cancelled
+                // task is still unwinding in the background.
+            }
         }
     }
 }
@@ -379,15 +441,23 @@ export function createToolTaskHandler(run, options) {
         const extra = asCreateTaskExtra(maybeExtra ?? argsOrExtra);
         const args = (maybeExtra ? argsOrExtra : undefined);
         if (options?.guard && !options.guard()) {
-            throw new McpError(ErrorCode.E_INVALID_INPUT, 'Client not initialized; wait for notifications/initialized');
+            throw new McpError(ErrorCode.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)}.`);
+            throw new McpError(ErrorCode.INVALID_INPUT, `Too many active tasks (limit: ${String(MAX_CONCURRENT_TASKS)}).`);
         }
         const task = await taskStore.createTask({
             ttl: resolveRequestedTaskTtl(extra.taskRequestedTtl),
+            pollInterval: options?.pollIntervalMs ?? TASK_POLL_INTERVAL_MS,
         });
+        const toolLabel = options?.toolName ?? 'tool';
+        try {
+            await taskStore.updateTaskStatus(task.taskId, 'working', `${toolLabel}: starting`);
+        }
+        catch {
+            // Best effort — status message is informational.
+        }
         publishTaskDiagnostics({
             phase: 'task_created',
             taskId: task.taskId,
@@ -399,8 +469,9 @@ export function createToolTaskHandler(run, options) {
             taskStore,
             taskId: task.taskId,
         };
+        void notifyTaskCreatedIfPossible(taskExtra, task.taskId, options?.toolName);
         void notifyTaskStatusIfPossible(taskExtra, taskStore, task.taskId, options?.toolName);
-        void runTaskInBackground(run, args, taskExtra, taskStore, task.taskId, options?.toolName);
+        void runTaskInBackground(run, args, taskExtra, taskStore, task.taskId, options?.toolName, options?.cancelPollMs);
         return { task };
     });
     const getTask = (async (argsOrExtra, maybeExtra) => {

package/dist/tools/tree.js

@@ -1,4 +1,4 @@
-import * as path from 'node:path';
+import { basename } from 'node:path';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { formatTreeAscii, treeDirectory, } from '../lib/file-operations/metadata.js';
@@ -48,7 +48,7 @@ export function registerTreeTool(server, options = {}) {
             timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
             context: { path: targetPath },
             run: async (signal) => {
-                const context = args.path ? path.basename(args.path) : '.';
+                const context = args.path ? basename(args.path) : '.';
                 let progressCursor = 0;
                 const knownTotal = args.maxEntries;
                 notifyProgress(extra, {
@@ -93,7 +93,7 @@ export function registerTreeTool(server, options = {}) {
                     throw error;
                 }
             },
-            onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, targetPath),
+            onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_DIRECTORY, targetPath),
         });
     };
     const wrappedHandler = wrapToolHandler(handler, {

package/dist/tools/write-file.js

@@ -1,7 +1,9 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import { basename, dirname } from 'node:path';
+import { withAbort } from '../lib/abort.js';
 import { ErrorCode } from '../lib/errors.js';
-import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
+import { atomicWriteFile } from '../lib/fs-helpers.js';
+import { Logger } from '../lib/logger.js';
 import { validatePathForWrite } from '../lib/paths.js';
 import { formatBytes } from '../config.js';
 import { WriteFileInputSchema, WriteFileOutputSchema } from '../schemas.js';
@@ -19,9 +21,10 @@ export const WRITE_FILE_TOOL = {
 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 withAbort(mkdir(dirname(validPath), { recursive: true }), signal);
     await atomicWriteFile(validPath, args.content, { encoding: 'utf-8', signal });
     const bytesWritten = Buffer.byteLength(args.content, 'utf-8');
+    Logger.info(`write: ${args.path} (${bytesWritten} bytes)`);
     return buildToolResponse(`Successfully wrote to file: ${args.path}`, {
         ok: true,
         path: validPath,
@@ -36,13 +39,13 @@ export function registerWriteFileTool(server, options = {}) {
         timedSignal: {},
         context: { path: args.path },
         run: (signal) => handleWriteFile(args, signal),
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
-        progressMessage: (args) => `🛠 write: ${path.basename(args.path)}`,
+        progressMessage: (args) => `🛠 write: ${basename(args.path)}`,
         completionMessage: (args, result) => {
-            const name = path.basename(args.path);
+            const name = basename(args.path);
             if (result.isError)
                 return `🛠 write: ${name} • failed`;
             const sc = result.structuredContent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.14.0",
+  "version": "1.14.1",
   "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",
@@ -75,28 +75,28 @@
   },
   "homepage": "https://github.com/j0hanz/filesystem-mcp#readme",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "commander": "^14.0.3",
-    "diff": "^8.0.3",
+    "diff": "^8.0.4",
     "ignore": "^7.0.5",
-    "re2": "^1.23.3",
-    "safe-regex2": "^5.0.0",
+    "re2": "^1.24.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/node": "^24",
-    "eslint": "^10.0.3",
+    "eslint": "^10.2.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-de-morgan": "^2.1.1",
     "eslint-plugin-depend": "^1.5.0",
+    "eslint-plugin-sonarjs": "^4.0.2",
     "eslint-plugin-unused-imports": "^4.4.1",
-    "knip": "^5.86.0",
+    "knip": "^6.3.1",
     "prettier": "^3.8.1",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.57.0"
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.1"
   },
   "engines": {
     "node": ">=24"