@j0hanz/filesystem-mcp 1.17.1 → 1.19.0

package/dist/tools/task-support.js

@@ -1,4 +1,4 @@
-import {} from '@modelcontextprotocol/server';
+import { isTerminal, RELATED_TASK_META_KEY, } from '@modelcontextprotocol/server';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { channel } from 'node:diagnostics_channel';
 import { performance } from 'node:perf_hooks';
@@ -7,8 +7,25 @@ import { DEFAULT_TASK_TTL_MS, MAX_CONCURRENT_TASKS, MAX_TASK_TTL_MS, TASK_CANCEL
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { Logger } from '../lib/logger.js';
 import { isRecord } from '../lib/utils.js';
-import { buildToolErrorResponse, maybeStripStructuredContentFromResult, resolveToolTaskSupportLevel, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, maybeStripStructuredContentFromResult, resolveToolTaskSupportLevel, toToolContext, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 const taskContext = new AsyncLocalStorage();
+/**
+ * Report an intermediate 'working' status update for the current task.
+ * No-op when called outside of a task context.
+ */
+export async function reportTaskStatus(statusMessage) {
+    const store = taskContext.getStore();
+    if (!store)
+        return;
+    const { taskId, taskStore, ctx, toolName } = store;
+    try {
+        await taskStore.updateTaskStatus(taskId, 'working', statusMessage);
+        await notifyTaskStatusIfPossible(ctx, taskStore, taskId, toolName);
+    }
+    catch {
+        // Best-effort: never fail tool execution for status updates.
+    }
+}
 const TASK_DIAGNOSTICS_CHANNEL = channel('filesystem-mcp:tasks');
 function publishTaskDiagnostics(event) {
     if (TASK_DIAGNOSTICS_CHANNEL.hasSubscribers) {
@@ -17,44 +34,33 @@ function publishTaskDiagnostics(event) {
 }
 // --- Type Guards & Helpers ---
 function hasTaskToolCapability(server) {
-    const capabilities = server.server.getCapabilities();
-    return capabilities.tasks?.requests?.tools?.call !== undefined;
+    try {
+        const capabilities = server.server.getCapabilities();
+        return capabilities.tasks?.requests?.tools?.call !== undefined;
+    }
+    catch {
+        return false;
+    }
 }
 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' &&
-        typeof value.getTask === 'function' &&
-        typeof value.storeTaskResult === 'function' &&
-        typeof value.getTaskResult === 'function');
-}
-function hasTaskStoreContext(value) {
-    return isRecord(value.task) && isRequestTaskStore(value.task.store);
-}
-function asCreateTaskContext(value) {
-    if (!hasTaskStoreContext(value)) {
+function assertCreateTaskContext(value) {
+    if (!isRecord(value.task) || typeof value.task.store !== 'object') {
         throw new McpError(ErrorCode.INVALID_INPUT, 'Task store not configured.');
     }
-    return value;
 }
-function asTaskRequestContext(value) {
-    if (!hasTaskStoreContext(value) ||
-        !isRecord(value.task) ||
+function assertTaskRequestContext(value) {
+    if (!isRecord(value.task) ||
+        typeof value.task.store !== 'object' ||
         typeof value.task.id !== 'string' ||
         value.task.id.length === 0) {
         throw new McpError(ErrorCode.INVALID_INPUT, 'Task id or store missing.');
     }
-    return value;
 }
 function toTaskToolContext(ctx) {
     return {
-        signal: ctx.mcpReq.signal,
-        ...(ctx.mcpReq._meta
-            ? { _meta: ctx.mcpReq._meta }
-            : {}),
-        sendNotification: async (notification) => ctx.mcpReq.notify(notification),
-        ...(hasTaskStoreContext(ctx) ? { taskStore: ctx.task.store } : {}),
+        ...toToolContext(ctx),
+        taskStore: ctx.task.store,
         ...(typeof ctx.task.id === 'string' && ctx.task.id.length > 0
             ? { taskId: ctx.task.id }
             : {}),
@@ -63,56 +69,11 @@ function toTaskToolContext(ctx) {
             : {}),
     };
 }
-const TASK_STATUSES = new Set([
-    'submitted',
-    'working',
-    'input_required',
-    'completed',
-    'failed',
-    'cancelled',
-    'unknown',
-]);
-function isTaskStatus(value) {
-    return typeof value === 'string' && TASK_STATUSES.has(value);
-}
-function normalizeGetTaskResult(value) {
-    if (!isRecord(value) || typeof value.taskId !== 'string') {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Invalid task object.');
-    }
-    const status = isTaskStatus(value.status) ? value.status : undefined;
-    if (!status) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Invalid task status.');
-    }
-    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 normalized = {
-        taskId: value.taskId,
-        status,
-        ttl,
-        createdAt,
-        lastUpdatedAt,
-    };
-    if (typeof value.pollInterval === 'number') {
-        normalized.pollInterval = value.pollInterval;
-    }
-    if (typeof value.statusMessage === 'string') {
-        normalized.statusMessage = value.statusMessage;
-    }
-    if (isRecord(value._meta)) {
-        normalized._meta = value._meta;
-    }
-    return normalized;
+function toGetTaskResult(task) {
+    return task;
 }
-function normalizeCallToolResult(value) {
-    if (isRecord(value) &&
-        Array.isArray(value.content) &&
-        value.content.every((entry) => isRecord(entry) && typeof entry.type === 'string')) {
-        return value;
-    }
-    throw new McpError(ErrorCode.INVALID_INPUT, 'Invalid stored task result.');
+function toCallToolResult(value) {
+    return value;
 }
 function getToolResultErrorCode(result) {
     if (!isRecord(result) || result.isError !== true)
@@ -149,7 +110,7 @@ function attachRelatedTaskMeta(result, taskId) {
         ...result,
         _meta: {
             ...existingMeta,
-            'io.modelcontextprotocol/related-task': { taskId },
+            [RELATED_TASK_META_KEY]: { taskId },
         },
     };
 }
@@ -182,16 +143,14 @@ function buildTaskStatusNotificationParams(task) {
     return params;
 }
 async function notifyTaskCreatedIfPossible(ctx, taskId, toolName) {
-    const { sendNotification } = ctx;
-    if (typeof sendNotification !== 'function')
+    if (!ctx.sendNotification)
         return;
-    const notify = sendNotification;
     try {
-        await notify({
+        await ctx.sendNotification({
             method: TASK_CREATED_NOTIFICATION_METHOD,
             params: {
                 _meta: {
-                    'io.modelcontextprotocol/related-task': {
+                    [RELATED_TASK_META_KEY]: {
                         taskId,
                     },
                 },
@@ -207,14 +166,12 @@ async function notifyTaskCreatedIfPossible(ctx, taskId, toolName) {
     }
 }
 async function notifyTaskStatusIfPossible(ctx, taskStore, taskId, toolName) {
-    const { sendNotification } = ctx;
-    if (typeof sendNotification !== 'function')
+    if (!ctx.sendNotification)
         return;
-    const notify = sendNotification;
     try {
         const task = await taskStore.getTask(taskId);
-        const normalized = await projectCancelledTaskStatus(taskStore, normalizeGetTaskResult(task));
-        await notify({
+        const normalized = await projectCancelledTaskStatus(taskStore, toGetTaskResult(task));
+        await ctx.sendNotification({
             method: TASK_STATUS_NOTIFICATION_METHOD,
             params: buildTaskStatusNotificationParams(normalized),
         });
@@ -257,12 +214,6 @@ function withoutStructuredContent(result) {
     delete stripped['structuredContent'];
     return stripped;
 }
-const TERMINAL_TASK_STATUSES = new Set([
-    'completed',
-    'failed',
-    'cancelled',
-    'unknown',
-]);
 const taskCreationLocks = new WeakMap();
 async function acquireTaskCreationLock(taskStore) {
     const previous = taskCreationLocks.get(taskStore) ?? Promise.resolve();
@@ -282,7 +233,7 @@ async function isTaskAlreadyTerminal(taskStore, taskId) {
         if (!isRecord(task))
             return false;
         const { status } = task;
-        return typeof status === 'string' && TERMINAL_TASK_STATUSES.has(status);
+        return typeof status === 'string' && isTerminal(status);
     }
     catch {
         return false;
@@ -301,7 +252,7 @@ async function countActiveTasks(taskStore) {
     for (const task of tasks) {
         if (!isRecord(task) || typeof task.status !== 'string')
             continue;
-        if (!TERMINAL_TASK_STATUSES.has(task.status)) {
+        if (!isTerminal(task.status)) {
             active += 1;
         }
     }
@@ -357,7 +308,7 @@ async function runTaskInBackground(run, args, ctx, taskStore, taskId, toolName,
     let taskStatuses;
     let result;
     try {
-        const rawResult = await taskContext.run({ taskId, toolName, startTime: start }, () => run(args, taskExtra));
+        const rawResult = await taskContext.run({ taskId, toolName, startTime: start, taskStore, ctx: taskExtra }, () => run(args, taskExtra));
         taskStatuses = resolveTaskResultStatuses(rawResult);
         result = isErrorResult(rawResult)
             ? withoutStructuredContent(rawResult)
@@ -392,10 +343,9 @@ async function runTaskInBackground(run, args, ctx, taskStore, taskId, toolName,
             lastUpdatedAt: new Date().toISOString(),
             statusMessage: 'Internal system error while storing result',
         };
-        const { sendNotification } = ctx;
-        if (typeof sendNotification === 'function') {
+        if (ctx.sendNotification) {
             try {
-                await sendNotification({
+                await ctx.sendNotification({
                     method: TASK_STATUS_NOTIFICATION_METHOD,
                     params: buildTaskStatusNotificationParams(syntheticTask),
                 });
@@ -451,7 +401,8 @@ export function createToolTaskHandler(run, options) {
         else {
             [args, serverCtx] = params;
         }
-        const ctx = toTaskToolContext(asCreateTaskContext(serverCtx));
+        assertCreateTaskContext(serverCtx);
+        const ctx = toTaskToolContext(serverCtx);
         if (options?.guard && !options.guard()) {
             throw new McpError(ErrorCode.INVALID_INPUT, 'Client not initialized; wait for notifications/initialized');
         }
@@ -493,26 +444,25 @@ export function createToolTaskHandler(run, options) {
         void runTaskInBackground(run, args, taskExtra, taskStore, task.taskId, options?.toolName, options?.cancelPollMs);
         return {
             task,
-            _meta: {
-                'io.modelcontextprotocol/model-immediate-response': `${toolLabel} task created — poll tasks/get for progress.`,
-            },
         };
     });
     const getTask = (async (...params) => {
         const serverCtx = params.length === 1 ? params[0] : params[1];
-        const ctx = toTaskToolContext(asTaskRequestContext(serverCtx));
+        assertTaskRequestContext(serverCtx);
+        const ctx = toTaskToolContext(serverCtx);
         const taskStore = getTaskStore(ctx);
         const taskId = getTaskId(ctx);
         const task = await taskStore.getTask(taskId);
-        return projectCancelledTaskStatus(taskStore, normalizeGetTaskResult(task));
+        return projectCancelledTaskStatus(taskStore, toGetTaskResult(task));
     });
     const getTaskResult = (async (...params) => {
         const serverCtx = params.length === 1 ? params[0] : params[1];
-        const ctx = toTaskToolContext(asTaskRequestContext(serverCtx));
+        assertTaskRequestContext(serverCtx);
+        const ctx = toTaskToolContext(serverCtx);
         const taskStore = getTaskStore(ctx);
         const taskId = getTaskId(ctx);
         const result = await taskStore.getTaskResult(taskId);
-        return attachRelatedTaskMeta(normalizeCallToolResult(result), taskId);
+        return attachRelatedTaskMeta(toCallToolResult(result), taskId);
     });
     return {
         createTask,

package/dist/tools/tree.js

@@ -1,6 +1,6 @@
 import { basename } from 'node:path';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
-import { ErrorCode } from '../lib/errors.js';
+import { classifyError, ErrorCode } from '../lib/errors.js';
 import { formatTreeAscii, treeDirectory, } from '../lib/file-operations/metadata.js';
 import { TreeInputSchema, TreeOutputSchema } from '../schemas.js';
 import { DIRECTORY_ICONS } from './icons.js';
@@ -56,7 +56,7 @@ export function registerTreeTool(server, options = {}) {
                 notifyProgress(ctx, {
                     current: 0,
                     total: knownTotal,
-                    message: `≣ tree: ${context}`,
+                    message: `${TREE_TOOL.title}: ${context}`,
                 });
                 const baseReporter = createProgressReporter(ctx);
                 const onProgress = (progress) => {
@@ -66,7 +66,7 @@ export function registerTreeTool(server, options = {}) {
                     baseReporter({
                         current,
                         total: knownTotal,
-                        message: `≣ tree: ${context} [${current} entries]`,
+                        message: `${TREE_TOOL.title}: ${context} [${current} entries]`,
                     });
                 };
                 try {
@@ -81,7 +81,7 @@ export function registerTreeTool(server, options = {}) {
                     notifyProgress(ctx, {
                         current: finalCurrent,
                         total: finalCurrent,
-                        message: `≣ tree: ${context} • ${suffix}`,
+                        message: `${TREE_TOOL.title}: ${context} • ${suffix}`,
                     });
                     return result;
                 }
@@ -90,7 +90,7 @@ export function registerTreeTool(server, options = {}) {
                     notifyProgress(ctx, {
                         current: finalCurrent,
                         total: finalCurrent,
-                        message: `≣ tree: ${context} • failed`,
+                        message: `${TREE_TOOL.title}: ${context} • ${classifyError(error)}`,
                     });
                     throw error;
                 }

package/dist/tools/write-file.js

@@ -48,13 +48,13 @@ export function registerWriteFileTool(server, options = {}) {
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
     registerStandardTool(server, WRITE_FILE_TOOL, handler, options, {
-        progressMessage: (args) => `🛠 write: ${basename(args.path)}`,
+        progressMessage: (args) => `${WRITE_FILE_TOOL.title}: ${basename(args.path)}`,
         completionMessage: (args, result) => {
             const name = basename(args.path);
             if (result.isError)
-                return `🛠 write: ${name} • failed`;
+                return `${WRITE_FILE_TOOL.title}: ${name} • ${result.errorCode}`;
             const sc = result.structuredContent;
-            return `🛠 write: ${name} • ${formatBytes(sc.bytesWritten ?? 0)}`;
+            return `${WRITE_FILE_TOOL.title}: ${name} • ${formatBytes(sc.bytesWritten ?? 0)}`;
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.17.1",
+  "version": "1.19.0",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "Secure filesystem MCP server for reading, writing, searching, diffing, and patching files.",
   "author": "j0hanz",