@j0hanz/filesystem-mcp 1.2.1 → 1.2.3

package/dist/tools/task-support.js

@@ -1,7 +1,7 @@
 import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { isRecord } from '../lib/type-guards.js';
-import { buildToolErrorResponse, withDefaultIcons } from './shared.js';
+import { buildToolErrorResponse, maybeStripStructuredContentFromResult, withDefaultIcons, } from './shared.js';
 function isExperimentalTaskRegistration(value) {
     if (!value || typeof value !== 'object')
         return false;
@@ -18,6 +18,29 @@ function getExperimentalTaskRegistration(server) {
         return undefined;
     return tasks;
 }
+function hasTaskToolCapability(server) {
+    const maybeServer = server;
+    const serverRuntime = maybeServer.server;
+    const capabilityGetter = serverRuntime?.getCapabilities;
+    if (typeof capabilityGetter !== 'function') {
+        // Fallback for tests or custom wrappers that provide only registerTool/experimental.
+        return true;
+    }
+    const capabilities = capabilityGetter.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);
+}
 const RELATED_TASK_META_KEY = 'io.modelcontextprotocol/related-task';
 const TASK_STATUS_NOTIFICATION_METHOD = 'notifications/tasks/status';
 function isRequestTaskStore(value) {
@@ -101,6 +124,35 @@ function normalizeCallToolResult(value) {
         return parsed.data;
     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)
+        return undefined;
+    const structured = result['structuredContent'];
+    if (!isRecord(structured))
+        return undefined;
+    const { error } = structured;
+    if (!isRecord(error))
+        return undefined;
+    const { code } = error;
+    return typeof code === 'string' ? code : undefined;
+}
+function isCancelledToolResult(result) {
+    return getToolResultErrorCode(result) === ErrorCode.E_CANCELLED;
+}
+async function projectCancelledTaskStatus(taskStore, task) {
+    if (task.status !== 'failed')
+        return task;
+    try {
+        const result = await taskStore.getTaskResult(task.taskId);
+        if (isCancelledToolResult(result)) {
+            return { ...task, status: 'cancelled' };
+        }
+    }
+    catch {
+        // Best effort only: task result may not be available yet.
+    }
+    return task;
+}
 function withRelatedTaskMeta(result, taskId) {
     const existingMeta = isRecord(result['_meta']) ? result['_meta'] : {};
     return {
@@ -129,7 +181,7 @@ async function notifyTaskStatusIfPossible(extra, taskStore, taskId) {
     const notify = sendNotification;
     try {
         const task = await taskStore.getTask(taskId);
-        const normalized = normalizeGetTaskResult(task);
+        const normalized = await projectCancelledTaskStatus(taskStore, normalizeGetTaskResult(task));
         await notify({
             method: TASK_STATUS_NOTIFICATION_METHOD,
             params: buildTaskStatusNotificationParams(normalized),
@@ -159,12 +211,6 @@ const TERMINAL_TASK_STATUSES = new Set([
     'failed',
     'cancelled',
 ]);
-function isTerminalTaskStoreError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const normalized = message.toLowerCase();
-    return (normalized.includes('terminal status') ||
-        normalized.includes('task not found'));
-}
 async function isTaskAlreadyTerminal(taskStore, taskId) {
     try {
         const task = await taskStore.getTask(taskId);
@@ -183,21 +229,20 @@ async function tryStoreTaskResult(taskStore, taskId, status, result) {
         await taskStore.storeTaskResult(taskId, status, resultWithTaskMeta);
     }
     catch (error) {
-        if (isTerminalTaskStoreError(error) ||
-            (await isTaskAlreadyTerminal(taskStore, taskId)))
+        if (await isTaskAlreadyTerminal(taskStore, taskId))
             return;
         throw error;
     }
 }
 async function runTaskInBackground(run, args, extra, taskStore, taskId) {
     try {
-        const result = await run(args, extra);
+        const result = maybeStripStructuredContentFromResult(await run(args, extra));
         const status = isErrorResult(result) ? 'failed' : 'completed';
         await tryStoreTaskResult(taskStore, taskId, status, result);
         await notifyTaskStatusIfPossible(extra, taskStore, taskId);
     }
     catch (error) {
-        const fallback = buildToolErrorResponse(error, ErrorCode.E_UNKNOWN);
+        const fallback = maybeStripStructuredContentFromResult(buildToolErrorResponse(error, ErrorCode.E_UNKNOWN));
         try {
             await tryStoreTaskResult(taskStore, taskId, 'failed', fallback);
             await notifyTaskStatusIfPossible(extra, taskStore, taskId);
@@ -213,6 +258,8 @@ async function runTaskInBackground(run, args, extra, taskStore, taskId) {
  * `server.registerTool`.
  */
 export function tryRegisterToolTask(server, toolName, toolDef, taskHandler, iconInfo) {
+    if (!hasTaskToolCapability(server))
+        return false;
     const tasks = getExperimentalTaskRegistration(server);
     if (!tasks?.registerToolTask)
         return false;
@@ -248,7 +295,7 @@ export function createToolTaskHandler(run, options) {
         const taskStore = getTaskStore(extra);
         const taskId = getTaskId(extra);
         const task = await taskStore.getTask(taskId);
-        return normalizeGetTaskResult(task);
+        return projectCancelledTaskStatus(taskStore, normalizeGetTaskResult(task));
     });
     const getTaskResult = (async (argsOrExtra, maybeExtra) => {
         const extra = asTaskRequestExtra(maybeExtra ?? argsOrExtra);

package/dist/tools/tree.js

@@ -3,7 +3,7 @@ import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { formatTreeAscii, treeDirectory } from '../lib/file-operations/tree.js';
 import { TreeInputSchema, TreeOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const TREE_TOOL = {
     title: 'Tree',
@@ -47,7 +47,8 @@ export function registerTreeTool(server, options = {}) {
             onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, targetPath),
         });
     };
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(TreeInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
             if (args.path) {
@@ -55,6 +56,18 @@ export function registerTreeTool(server, options = {}) {
             }
             return '≣ tree';
         },
+        completionMessage: (args, result) => {
+            const base = args.path ? path.basename(args.path) : '.';
+            if (result.isError)
+                return `≣ tree: ${base} • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `≣ tree: ${base} • failed`;
+            const count = sc.totalEntries ?? 0;
+            if (sc.truncated)
+                return `≣ tree: ${base} • ${count} entries [truncated]`;
+            return `≣ tree: ${base} • ${count} ${count === 1 ? 'entry' : 'entries'}`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'tree', TREE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/dist/tools/write-file.js

@@ -4,7 +4,7 @@ import { ErrorCode } from '../lib/errors.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/path-validation.js';
 import { WriteFileInputSchema, WriteFileOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 const WRITE_FILE_TOOL = {
     title: 'Write File',
@@ -34,9 +34,19 @@ export function registerWriteFileTool(server, options = {}) {
         run: (signal) => handleWriteFile(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
+    const validatedHandler = withValidatedArgs(WriteFileInputSchema, handler);
+    const wrappedHandler = wrapToolHandler(validatedHandler, {
         guard: options.isInitialized,
-        progressMessage: (args) => `🛠 write: ${path.basename(args.path)}`,
+        progressMessage: (args) => `🛠 write: ${path.basename(args.path)} [${args.content.length} chars]`,
+        completionMessage: (args, result) => {
+            const name = path.basename(args.path);
+            if (result.isError)
+                return `🛠 write: ${name} • failed`;
+            const sc = result.structuredContent;
+            if (!sc.ok)
+                return `🛠 write: ${name} • failed`;
+            return `🛠 write: ${name} • ${sc.bytesWritten ?? 0} bytes`;
+        },
     });
     if (registerToolTaskIfAvailable(server, 'write', WRITE_FILE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "MCP Server that enables LLMs to interact with the local filesystem.",
   "type": "module",
@@ -31,12 +31,14 @@
     "start": "node dist/index.js",
     "format": "prettier --write .",
     "type-check": "node scripts/tasks.mjs type-check",
+    "type-check:src": "node node_modules/typescript/bin/tsc -p tsconfig.json --noEmit",
+    "type-check:tests": "node node_modules/typescript/bin/tsc -p tsconfig.test.json --noEmit",
     "type-check:diagnostics": "tsc --noEmit --extendedDiagnostics",
     "type-check:trace": "node -e \"require('fs').rmSync('.ts-trace',{recursive:true,force:true})\" && tsc --noEmit --generateTrace .ts-trace",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "node scripts/tasks.mjs test",
-    "test:fast": "node --test --import tsx/esm src/__tests__/**/*.test.ts",
+    "test:fast": "node --test --import tsx/esm src/__tests__/**/*.test.ts node-tests/**/*.test.ts",
     "test:coverage": "node scripts/tasks.mjs test --coverage",
     "knip": "knip",
     "knip:fix": "knip --fix",