@j0hanz/filesystem-mcp 1.9.0 → 1.10.0

package/dist/tools/shared.js

@@ -42,18 +42,16 @@ export function maybeStripStructuredContentFromResult(result) {
         return result;
     if (!Object.hasOwn(result, 'structuredContent'))
         return result;
-    const rest = { ...result };
-    delete rest['structuredContent'];
-    return rest;
+    const stripped = Object.fromEntries(Object.entries(result).filter(([key]) => key !== 'structuredContent'));
+    return stripped;
 }
 function maybeStripOutputSchema(tool) {
     if (!shouldStripStructuredOutput())
         return tool;
     if (!Object.hasOwn(tool, 'outputSchema'))
         return tool;
-    const mutable = { ...tool };
-    delete mutable['outputSchema'];
-    return mutable;
+    const stripped = Object.fromEntries(Object.entries(tool).filter(([key]) => key !== 'outputSchema'));
+    return stripped;
 }
 function buildTextPreview(text) {
     if (text.length <= MAX_INLINE_PREVIEW_CHARS)
@@ -83,11 +81,17 @@ export function maybeExternalizeTextContent(resourceStore, content, params) {
     };
 }
 export function buildResourceLink(params) {
+    const descParts = [];
+    if (params.description)
+        descParts.push(params.description);
+    if (params.expiresAt)
+        descParts.push(`Expires: ${params.expiresAt}`);
+    const description = descParts.length > 0 ? descParts.join(' · ') : undefined;
     return {
         type: 'resource_link',
         uri: params.uri,
         name: params.name,
-        ...(params.description ? { description: params.description } : {}),
+        ...(description ? { description } : {}),
         ...(params.mimeType ? { mimeType: params.mimeType } : {}),
     };
 }
@@ -207,6 +211,18 @@ function buildNotInitializedResult() {
     return buildToolErrorResponse(NOT_INITIALIZED_ERROR, ErrorCode.E_INVALID_INPUT);
 }
 async function reportProgress(extra, progress) {
+    await updateTaskStoreProgress(extra, progress);
+    await sendMcpProgressNotification(extra, progress);
+}
+function formatTaskStatusMessage(progress) {
+    if (progress.total !== undefined) {
+        return progress.message
+            ? `${progress.message} (${progress.current}/${progress.total})`
+            : `${progress.current}/${progress.total}`;
+    }
+    return progress.message ?? `${progress.current}`;
+}
+async function updateTaskStoreProgress(extra, progress) {
     const taskExtra = extra;
     if (typeof taskExtra.taskId === 'string' &&
         taskExtra.taskStore !== undefined &&
@@ -214,22 +230,15 @@ async function reportProgress(extra, progress) {
         const store = taskExtra.taskStore;
         if (typeof store.updateTaskStatus === 'function') {
             try {
-                let statusMessage = progress.message;
-                if (progress.total !== undefined) {
-                    statusMessage = statusMessage
-                        ? `${statusMessage} (${progress.current}/${progress.total})`
-                        : `${progress.current}/${progress.total}`;
-                }
-                else {
-                    statusMessage ??= `${progress.current}`;
-                }
-                await store.updateTaskStatus(taskExtra.taskId, 'working', statusMessage);
+                await store.updateTaskStatus(taskExtra.taskId, 'working', formatTaskStatusMessage(progress));
             }
             catch (error) {
                 console.error('Failed to update task status message:', error);
             }
         }
     }
+}
+async function sendMcpProgressNotification(extra, progress) {
     if (canSendProgress(extra)) {
         try {
             await extra.sendNotification({
@@ -282,9 +291,10 @@ export function notifyProgress(extra, progress) {
         return;
     void reportProgress(extra, progress);
 }
-export function createToolProgressSession(extra, startMessage) {
+export function createToolProgressSession(extra, startMessage, initialTotal) {
     notifyProgress(extra, {
         current: 0,
+        ...(initialTotal !== undefined ? { total: initialTotal } : {}),
         message: startMessage,
     });
     let cursor = 0;
@@ -325,9 +335,15 @@ export function createToolProgressSession(extra, startMessage) {
     };
 }
 export function createBatchProgressCallbacks(extra, params) {
-    const progress = createToolProgressSession(extra, `${params.toolLabel}: ${params.context}`);
+    const progress = createToolProgressSession(extra, `${params.toolLabel}: ${params.context}`, params.totalItems);
+    let itemsDone = 0;
     const onItemComplete = () => {
-        progress.increment((current) => `${params.toolLabel}: ${params.context} [${current}/${params.totalItems} ${params.itemVerb}]`);
+        itemsDone++;
+        progress.update({
+            current: itemsDone,
+            total: params.totalItems,
+            message: `${params.toolLabel}: ${params.context} [${itemsDone}/${params.totalItems} ${params.itemVerb}]`,
+        });
     };
     return { progress, onItemComplete };
 }

package/dist/tools/stat-many.js

@@ -79,7 +79,7 @@ export function registerGetMultipleFileInfoTool(server, options = {}) {
                     toolLabel: '🕮 stat_many',
                     context,
                     totalItems: args.paths.length,
-                    itemVerb: 'scanned',
+                    itemVerb: 'done',
                 });
                 try {
                     const result = await handleGetMultipleFileInfo(args, signal, onItemComplete);

package/dist/tools/stat.js

@@ -5,6 +5,7 @@ import { getFileInfo } from '../lib/file-operations/metadata.js';
 import { formatBytes, joinLines } from '../config.js';
 import { GetFileInfoInputSchema, GetFileInfoOutputSchema } from '../schemas.js';
 import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 export const GET_FILE_INFO_TOOL = {
     name: 'stat',
     title: 'Get File Info',
@@ -13,6 +14,7 @@ export const GET_FILE_INFO_TOOL = {
     inputSchema: GetFileInfoInputSchema,
     outputSchema: GetFileInfoOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    taskSupport: 'optional',
     nuances: ['Use before read/search when file size/type uncertainty exists.'],
 };
 function formatFileInfoDetails(info) {
@@ -62,5 +64,7 @@ export function registerGetFileInfoTool(server, options = {}) {
         },
     });
     const validatedHandler = withValidatedArgs(GetFileInfoInputSchema, wrappedHandler);
+    if (registerToolTaskIfAvailable(server, 'stat', GET_FILE_INFO_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
+        return;
     server.registerTool('stat', withDefaultIcons({ ...GET_FILE_INFO_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/task-support.js

@@ -1,5 +1,6 @@
 import { channel } from 'node:diagnostics_channel';
 import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
+import { DEFAULT_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';
@@ -44,7 +45,6 @@ function hasTaskToolCapability(server) {
     const { call } = tools;
     return isRecord(call);
 }
-const RELATED_TASK_META_KEY = 'io.modelcontextprotocol/related-task';
 const TASK_STATUS_NOTIFICATION_METHOD = 'notifications/tasks/status';
 const TASK_DIAGNOSTICS_CHANNEL = channel('filesystem-mcp:tasks');
 function publishTaskDiagnostics(event) {
@@ -169,13 +169,6 @@ async function projectCancelledTaskStatus(taskStore, task) {
     }
     return task;
 }
-function withRelatedTaskMeta(result, taskId) {
-    const existingMeta = isRecord(result['_meta']) ? result['_meta'] : {};
-    return {
-        ...result,
-        _meta: { ...existingMeta, [RELATED_TASK_META_KEY]: { taskId } },
-    };
-}
 function buildTaskStatusNotificationParams(task) {
     const params = {
         taskId: task.taskId,
@@ -259,9 +252,8 @@ async function isTaskAlreadyTerminal(taskStore, taskId) {
     }
 }
 async function tryStoreTaskResult(taskStore, taskId, status, result) {
-    const resultWithTaskMeta = withRelatedTaskMeta(result, taskId);
     try {
-        await taskStore.storeTaskResult(taskId, status, resultWithTaskMeta);
+        await taskStore.storeTaskResult(taskId, status, result);
     }
     catch (error) {
         if (await isTaskAlreadyTerminal(taskStore, taskId))
@@ -352,7 +344,7 @@ export function createToolTaskHandler(run, options) {
         }
         const taskStore = getTaskStore(extra);
         const task = await taskStore.createTask({
-            ttl: extra.taskRequestedTtl ?? null,
+            ttl: extra.taskRequestedTtl ?? DEFAULT_TASK_TTL_MS,
         });
         publishTaskDiagnostics({
             phase: 'task_created',
@@ -383,7 +375,7 @@ export function createToolTaskHandler(run, options) {
         const taskStore = getTaskStore(extra);
         const taskId = getTaskId(extra);
         const result = await taskStore.getTaskResult(taskId);
-        return normalizeCallToolResult(withRelatedTaskMeta(result, taskId));
+        return normalizeCallToolResult(result);
     });
     return {
         createTask,

package/dist/tools/tree.js

@@ -23,6 +23,7 @@ async function handleTree(args, signal, onProgress) {
         maxEntries: args.maxEntries,
         includeHidden: args.includeHidden,
         includeIgnored: args.includeIgnored,
+        includeSizes: args.includeSizes,
         ...(signal ? { signal } : {}),
         ...(onProgress ? { onProgress } : {}),
     });
@@ -49,8 +50,10 @@ export function registerTreeTool(server, options = {}) {
             run: async (signal) => {
                 const context = args.path ? path.basename(args.path) : '.';
                 let progressCursor = 0;
+                const knownTotal = args.maxEntries;
                 notifyProgress(extra, {
                     current: 0,
+                    total: knownTotal,
                     message: `≣ tree: ${context}`,
                 });
                 const baseReporter = createProgressReporter(extra);
@@ -60,6 +63,7 @@ export function registerTreeTool(server, options = {}) {
                         progressCursor = current;
                     baseReporter({
                         current,
+                        total: knownTotal,
                         message: `≣ tree: ${context} [${current} entries]`,
                     });
                 };

package/dist/tools/write-file.js

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 import { ErrorCode } from '../lib/errors.js';
 import { atomicWriteFile, withAbort } from '../lib/fs-helpers.js';
 import { validatePathForWrite } from '../lib/paths.js';
+import { formatBytes } from '../config.js';
 import { WriteFileInputSchema, WriteFileOutputSchema } from '../schemas.js';
 import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
@@ -16,6 +17,7 @@ export const WRITE_FILE_TOOL = {
     gotchas: [
         '`write` replaces ALL existing content — use `edit` for partial updates.',
     ],
+    taskSupport: 'optional',
 };
 async function handleWriteFile(args, signal) {
     const validPath = await validatePathForWrite(args.path, signal);
@@ -40,7 +42,7 @@ export function registerWriteFileTool(server, options = {}) {
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
-        progressMessage: (args) => `🛠 write: ${path.basename(args.path)} [${args.content.length} chars]`,
+        progressMessage: (args) => `🛠 write: ${path.basename(args.path)}`,
         completionMessage: (args, result) => {
             const name = path.basename(args.path);
             if (result.isError)
@@ -48,7 +50,7 @@ export function registerWriteFileTool(server, options = {}) {
             const sc = result.structuredContent;
             if (!sc.ok)
                 return `🛠 write: ${name} • failed`;
-            return `🛠 write: ${name} • ${sc.bytesWritten ?? 0} bytes`;
+            return `🛠 write: ${name} • ${formatBytes(sc.bytesWritten ?? 0)} written`;
         },
     });
     const validatedHandler = withValidatedArgs(WriteFileInputSchema, wrappedHandler);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
-  "description": "MCP Server that enables LLMs to interact with the local filesystem.",
+  "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",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,13 +48,23 @@
   "keywords": [
     "mcp",
     "model-context-protocol",
+    "mcp-server",
     "filesystem",
-    "scanner",
+    "file-management",
+    "file-operations",
+    "grep",
+    "glob",
+    "diff",
+    "patch",
     "search",
-    "analysis",
-    "exploration",
-    "manipulation",
-    "server"
+    "security",
+    "server",
+    "stdio",
+    "sse",
+    "typescript",
+    "nodejs",
+    "llm",
+    "cli"
   ],
   "author": "j0hanz",
   "license": "MIT",
@@ -80,7 +90,6 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-de-morgan": "^2.1.1",
     "eslint-plugin-depend": "^1.5.0",
-    "eslint-plugin-sonarjs": "^4.0.0",
     "eslint-plugin-unused-imports": "^4.4.1",
     "jscpd": "^4.0.8",
     "knip": "^5.85.0",