@j0hanz/filesystem-mcp 1.1.2 → 1.2.1

package/dist/tools/stat.js

@@ -3,41 +3,15 @@ import { formatBytes, joinLines } from '../config.js';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { getFileInfo } from '../lib/file-operations/file-info.js';
-import { createTimedAbortSignal } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
 import { GetFileInfoInputSchema, GetFileInfoOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
+import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
 const GET_FILE_INFO_TOOL = {
     title: 'Get File Info',
     description: 'Get metadata (size, modified time, permissions, mime type) for a file or directory.',
     inputSchema: GetFileInfoInputSchema,
     outputSchema: GetFileInfoOutputSchema,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
+    annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
-function buildFileInfoPayload(info) {
-    return {
-        name: info.name,
-        path: info.path,
-        type: info.type,
-        size: info.size,
-        ...(info.tokenEstimate !== undefined
-            ? { tokenEstimate: info.tokenEstimate }
-            : {}),
-        created: info.created.toISOString(),
-        modified: info.modified.toISOString(),
-        accessed: info.accessed.toISOString(),
-        permissions: info.permissions,
-        isHidden: info.isHidden,
-        ...(info.mimeType !== undefined ? { mimeType: info.mimeType } : {}),
-        ...(info.symlinkTarget !== undefined
-            ? { symlinkTarget: info.symlinkTarget }
-            : {}),
-    };
-}
 function formatFileInfoDetails(info) {
     const lines = [
         `${info.name} (${info.type})`,
@@ -63,15 +37,14 @@ async function handleGetFileInfo(args, signal) {
     return buildToolResponse(formatFileInfoDetails(info), structured);
 }
 export function registerGetFileInfoTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('stat', () => withToolErrorHandling(async () => {
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
-        try {
-            return await handleGetFileInfo(args, signal);
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, args.path)), { path: args.path });
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'stat',
+        extra,
+        timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
+        context: { path: args.path },
+        run: (signal) => handleGetFileInfo(args, signal),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, args.path),
+    });
     server.registerTool('stat', withDefaultIcons({ ...GET_FILE_INFO_TOOL }, options.iconInfo), wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🕮 stat: ${path.basename(args.path)}`,

package/dist/tools/task-support.d.ts

@@ -1,13 +1,21 @@
 import type { ToolTaskHandler } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { AnySchema, SchemaOutput, ShapeOutput, ZodRawShapeCompat } from '@modelcontextprotocol/sdk/server/zod-compat.js';
 import type { RequestTaskStore } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import type { ToolExtra, ToolResult } from './shared.js';
+import type { IconInfo, ToolExtra, ToolResult } from './shared.js';
 type TaskToolExtra = ToolExtra & {
     taskId?: string;
     taskStore?: RequestTaskStore;
     taskRequestedTtl?: number | null;
 };
 type ToolArgs<Args extends ZodRawShapeCompat | AnySchema | undefined> = Args extends ZodRawShapeCompat ? ShapeOutput<Args> : Args extends AnySchema ? SchemaOutput<Args> : undefined;
+/**
+ * Registers a tool preferring task-capable registration when available, and
+ * returns `true`. Returns `false` so the caller can fall through to standard
+ * `server.registerTool`.
+ */
+export declare function tryRegisterToolTask<Args extends ZodRawShapeCompat | AnySchema | undefined>(server: McpServer, toolName: string, toolDef: object, taskHandler: ToolTaskHandler<Args>, iconInfo: IconInfo | undefined): boolean;
+export declare function registerToolTaskIfAvailable<Args extends ZodRawShapeCompat | AnySchema | undefined, Result>(server: McpServer, toolName: string, toolDef: object, run: (args: ToolArgs<Args>, extra: TaskToolExtra) => Promise<ToolResult<Result>>, iconInfo: IconInfo | undefined, guard?: () => boolean): boolean;
 export declare function createToolTaskHandler<Result>(run: (args: undefined, extra: TaskToolExtra) => Promise<ToolResult<Result>>, options?: {
     guard?: () => boolean;
 }): ToolTaskHandler;

package/dist/tools/task-support.js

@@ -1,11 +1,25 @@
 import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
 import { ErrorCode, McpError } from '../lib/errors.js';
-import { buildToolErrorResponse } from './shared.js';
+import { isRecord } from '../lib/type-guards.js';
+import { buildToolErrorResponse, withDefaultIcons } from './shared.js';
+function isExperimentalTaskRegistration(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const { registerToolTask } = value;
+    return (registerToolTask === undefined || typeof registerToolTask === 'function');
+}
+function getExperimentalTaskRegistration(server) {
+    const serverWithExperimental = server;
+    const { experimental } = serverWithExperimental;
+    if (!experimental || typeof experimental !== 'object')
+        return undefined;
+    const { tasks } = experimental;
+    if (!isExperimentalTaskRegistration(tasks))
+        return undefined;
+    return tasks;
+}
 const RELATED_TASK_META_KEY = 'io.modelcontextprotocol/related-task';
 const TASK_STATUS_NOTIFICATION_METHOD = 'notifications/tasks/status';
-function isRecord(value) {
-    return value !== null && typeof value === 'object';
-}
 function isRequestTaskStore(value) {
     if (!isRecord(value))
         return false;
@@ -41,26 +55,24 @@ const TASK_STATUSES = new Set([
     'failed',
     'cancelled',
 ]);
+function isTaskStatus(value) {
+    return (typeof value === 'string' &&
+        TASK_STATUSES.has(value));
+}
 function parseTaskStatus(value) {
-    if (value === 'working' ||
-        value === 'input_required' ||
-        value === 'completed' ||
-        value === 'failed' ||
-        value === 'cancelled') {
-        return value;
-    }
-    return undefined;
+    return isTaskStatus(value) ? value : undefined;
 }
 function normalizeGetTaskResult(value) {
     if (!isRecord(value) || typeof value['taskId'] !== 'string') {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'Invalid task object.');
     }
     const status = parseTaskStatus(value['status']);
-    if (!status || !TASK_STATUSES.has(status)) {
+    if (!status) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'Invalid task status.');
     }
-    const now = new Date().toISOString();
-    const createdAt = typeof value['createdAt'] === 'string' ? value['createdAt'] : now;
+    const createdAt = typeof value['createdAt'] === 'string'
+        ? value['createdAt']
+        : new Date().toISOString();
     const lastUpdatedAt = typeof value['lastUpdatedAt'] === 'string'
         ? value['lastUpdatedAt']
         : createdAt;
@@ -90,51 +102,35 @@ function normalizeCallToolResult(value) {
     throw new McpError(ErrorCode.E_INVALID_INPUT, 'Stored task result is not a valid tool result.');
 }
 function withRelatedTaskMeta(result, taskId) {
-    if (!isRecord(result)) {
-        return {
-            _meta: {
-                [RELATED_TASK_META_KEY]: { taskId },
-            },
-        };
-    }
     const existingMeta = isRecord(result['_meta']) ? result['_meta'] : {};
     return {
         ...result,
-        _meta: {
-            ...existingMeta,
-            [RELATED_TASK_META_KEY]: { taskId },
-        },
+        _meta: { ...existingMeta, [RELATED_TASK_META_KEY]: { taskId } },
     };
 }
-function getTaskStatusNotificationSender(extra) {
-    const candidate = extra.sendNotification;
-    return typeof candidate === 'function'
-        ? candidate
-        : undefined;
-}
 function buildTaskStatusNotificationParams(task) {
-    return {
+    const params = {
         taskId: task.taskId,
         status: task.status,
         ttl: task.ttl,
         createdAt: task.createdAt,
         lastUpdatedAt: task.lastUpdatedAt,
-        ...(task.pollInterval !== undefined
-            ? { pollInterval: task.pollInterval }
-            : {}),
-        ...(task.statusMessage !== undefined
-            ? { statusMessage: task.statusMessage }
-            : {}),
     };
+    if (task.pollInterval !== undefined)
+        params.pollInterval = task.pollInterval;
+    if (task.statusMessage !== undefined)
+        params.statusMessage = task.statusMessage;
+    return params;
 }
 async function notifyTaskStatusIfPossible(extra, taskStore, taskId) {
-    const sendNotification = getTaskStatusNotificationSender(extra);
-    if (!sendNotification)
+    const { sendNotification } = extra;
+    if (typeof sendNotification !== 'function')
         return;
+    const notify = sendNotification;
     try {
         const task = await taskStore.getTask(taskId);
         const normalized = normalizeGetTaskResult(task);
-        await sendNotification({
+        await notify({
             method: TASK_STATUS_NOTIFICATION_METHOD,
             params: buildTaskStatusNotificationParams(normalized),
         });
@@ -158,49 +154,75 @@ function getTaskId(extra) {
 function isErrorResult(result) {
     return 'isError' in result && result.isError === true;
 }
-const TERMINAL_TASK_STATUSES = new Set(['completed', 'failed', 'cancelled']);
-function getTaskStatus(task) {
-    if (!isRecord(task))
-        return undefined;
-    const { status } = task;
-    return typeof status === 'string' ? status : undefined;
-}
-function isTerminalTaskStatus(status) {
-    if (!status)
-        return false;
-    return TERMINAL_TASK_STATUSES.has(status);
-}
+const TERMINAL_TASK_STATUSES = new Set([
+    'completed',
+    '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 getCurrentTaskStatus(taskStore, taskId) {
+async function isTaskAlreadyTerminal(taskStore, taskId) {
     try {
         const task = await taskStore.getTask(taskId);
-        return getTaskStatus(task);
+        if (!isRecord(task))
+            return false;
+        const { status } = task;
+        return typeof status === 'string' && TERMINAL_TASK_STATUSES.has(status);
     }
     catch {
-        return undefined;
+        return false;
     }
 }
 async function tryStoreTaskResult(taskStore, taskId, status, result) {
     const resultWithTaskMeta = withRelatedTaskMeta(result, taskId);
-    const beforeStatus = await getCurrentTaskStatus(taskStore, taskId);
-    if (isTerminalTaskStatus(beforeStatus))
-        return;
     try {
         await taskStore.storeTaskResult(taskId, status, resultWithTaskMeta);
     }
     catch (error) {
-        const afterStatus = await getCurrentTaskStatus(taskStore, taskId);
-        if (isTerminalTaskStatus(afterStatus) || isTerminalTaskStoreError(error)) {
+        if (isTerminalTaskStoreError(error) ||
+            (await isTaskAlreadyTerminal(taskStore, taskId)))
             return;
-        }
         throw error;
     }
 }
+async function runTaskInBackground(run, args, extra, taskStore, taskId) {
+    try {
+        const result = 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);
+        try {
+            await tryStoreTaskResult(taskStore, taskId, 'failed', fallback);
+            await notifyTaskStatusIfPossible(extra, taskStore, taskId);
+        }
+        catch (innerError) {
+            console.error(`Failed to store task failure result for task ${taskId}:`, innerError);
+        }
+    }
+}
+/**
+ * Registers a tool preferring task-capable registration when available, and
+ * returns `true`. Returns `false` so the caller can fall through to standard
+ * `server.registerTool`.
+ */
+export function tryRegisterToolTask(server, toolName, toolDef, taskHandler, iconInfo) {
+    const tasks = getExperimentalTaskRegistration(server);
+    if (!tasks?.registerToolTask)
+        return false;
+    tasks.registerToolTask(toolName, withDefaultIcons({ ...toolDef, execution: { taskSupport: 'optional' } }, iconInfo), taskHandler);
+    return true;
+}
+export function registerToolTaskIfAvailable(server, toolName, toolDef, run, iconInfo, guard) {
+    const taskOptions = guard ? { guard } : undefined;
+    return tryRegisterToolTask(server, toolName, toolDef, createToolTaskHandler(run, taskOptions), iconInfo);
+}
 export function createToolTaskHandler(run, options) {
     const createTask = (async (argsOrExtra, maybeExtra) => {
         const extra = asCreateTaskExtra(maybeExtra ?? argsOrExtra);
@@ -218,24 +240,7 @@ export function createToolTaskHandler(run, options) {
             taskId: task.taskId,
         };
         void notifyTaskStatusIfPossible(taskExtra, taskStore, task.taskId);
-        void (async () => {
-            try {
-                const result = await run(args, taskExtra);
-                const status = isErrorResult(result) ? 'failed' : 'completed';
-                await tryStoreTaskResult(taskStore, task.taskId, status, result);
-                await notifyTaskStatusIfPossible(taskExtra, taskStore, task.taskId);
-            }
-            catch (error) {
-                const fallback = buildToolErrorResponse(error, ErrorCode.E_UNKNOWN);
-                try {
-                    await tryStoreTaskResult(taskStore, task.taskId, 'failed', fallback);
-                    await notifyTaskStatusIfPossible(taskExtra, taskStore, task.taskId);
-                }
-                catch {
-                    // Swallow to avoid unhandled rejections from background task writes.
-                }
-            }
-        })();
+        void runTaskInBackground(run, args, taskExtra, taskStore, task.taskId);
         return { task };
     });
     const getTask = (async (argsOrExtra, maybeExtra) => {

package/dist/tools/tree.js

@@ -2,11 +2,9 @@ import * as path 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/tree.js';
-import { createTimedAbortSignal } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
 import { TreeInputSchema, TreeOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, getExperimentalTaskRegistration, resolvePathOrRoot, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
-import { createToolTaskHandler } from './task-support.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 const TREE_TOOL = {
     title: 'Tree',
     description: 'Render a directory tree (bounded recursion). ' +
@@ -14,11 +12,7 @@ const TREE_TOOL = {
         'Note: maxDepth=0 returns only the root node with empty children array.',
     inputSchema: TreeInputSchema,
     outputSchema: TreeOutputSchema,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
+    annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 async function handleTree(args, signal) {
     const basePath = resolvePathOrRoot(args.path);
@@ -44,15 +38,14 @@ async function handleTree(args, signal) {
 export function registerTreeTool(server, options = {}) {
     const handler = (args, extra) => {
         const targetPath = args.path ?? '.';
-        return withToolDiagnostics('tree', () => withToolErrorHandling(async () => {
-            const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
-            try {
-                return await handleTree(args, signal);
-            }
-            finally {
-                cleanup();
-            }
-        }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, targetPath)), { path: targetPath });
+        return executeToolWithDiagnostics({
+            toolName: 'tree',
+            extra,
+            timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
+            context: { path: targetPath },
+            run: (signal) => handleTree(args, signal),
+            onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_DIRECTORY, targetPath),
+        });
     };
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
@@ -63,16 +56,7 @@ export function registerTreeTool(server, options = {}) {
             return '≣ tree';
         },
     });
-    const taskOptions = options.isInitialized
-        ? { guard: options.isInitialized }
-        : undefined;
-    const tasks = getExperimentalTaskRegistration(server);
-    if (tasks?.registerToolTask) {
-        tasks.registerToolTask('tree', withDefaultIcons({
-            ...TREE_TOOL,
-            execution: { taskSupport: 'optional' },
-        }, options.iconInfo), createToolTaskHandler(wrappedHandler, taskOptions));
+    if (registerToolTaskIfAvailable(server, 'tree', TREE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;
-    }
     server.registerTool('tree', withDefaultIcons({ ...TREE_TOOL }, options.iconInfo), wrappedHandler);
 }

package/dist/tools/write-file.js

@@ -1,21 +1,17 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { ErrorCode } from '../lib/errors.js';
-import { atomicWriteFile, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.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, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 const WRITE_FILE_TOOL = {
     title: 'Write File',
     description: 'Write content to a file. Creates the file if it does not exist.',
     inputSchema: WriteFileInputSchema,
     outputSchema: WriteFileOutputSchema,
-    annotations: {
-        readOnlyHint: false,
-        destructiveHint: true,
-        openWorldHint: false,
-    },
+    annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
 };
 async function handleWriteFile(args, signal) {
     const validPath = await validatePathForWrite(args.path, signal);
@@ -30,17 +26,19 @@ async function handleWriteFile(args, signal) {
     });
 }
 export function registerWriteFileTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('write', () => withToolErrorHandling(async () => {
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal);
-        try {
-            return await handleWriteFile(args, signal);
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path)), { path: args.path });
-    server.registerTool('write', withDefaultIcons({ ...WRITE_FILE_TOOL }, options.iconInfo), wrapToolHandler(handler, {
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'write',
+        extra,
+        timedSignal: {},
+        context: { path: args.path },
+        run: (signal) => handleWriteFile(args, signal),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
+    });
+    const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🛠 write: ${path.basename(args.path)}`,
-    }));
+    });
+    if (registerToolTaskIfAvailable(server, 'write', WRITE_FILE_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
+        return;
+    server.registerTool('write', withDefaultIcons({ ...WRITE_FILE_TOOL }, options.iconInfo), wrappedHandler);
 }

package/dist/tools.js

@@ -17,23 +17,28 @@ import { registerGetFileInfoTool } from './tools/stat.js';
 import { registerTreeTool } from './tools/tree.js';
 import { registerWriteFileTool } from './tools/write-file.js';
 export { buildToolErrorResponse, buildToolResponse } from './tools/shared.js';
+const TOOL_REGISTRARS = [
+    registerListAllowedDirectoriesTool,
+    registerListDirectoryTool,
+    registerSearchFilesTool,
+    registerTreeTool,
+    registerReadFileTool,
+    registerReadMultipleFilesTool,
+    registerGetFileInfoTool,
+    registerGetMultipleFileInfoTool,
+    registerSearchContentTool,
+    registerCreateDirectoryTool,
+    registerWriteFileTool,
+    registerEditFileTool,
+    registerMoveFileTool,
+    registerDeleteFileTool,
+    registerCalculateHashTool,
+    registerDiffFilesTool,
+    registerApplyPatchTool,
+    registerSearchAndReplaceTool,
+];
 export function registerAllTools(server, options = {}) {
-    registerListAllowedDirectoriesTool(server, options);
-    registerListDirectoryTool(server, options);
-    registerSearchFilesTool(server, options);
-    registerTreeTool(server, options);
-    registerReadFileTool(server, options);
-    registerReadMultipleFilesTool(server, options);
-    registerGetFileInfoTool(server, options);
-    registerGetMultipleFileInfoTool(server, options);
-    registerSearchContentTool(server, options);
-    registerCreateDirectoryTool(server, options);
-    registerWriteFileTool(server, options);
-    registerEditFileTool(server, options);
-    registerMoveFileTool(server, options);
-    registerDeleteFileTool(server, options);
-    registerCalculateHashTool(server, options);
-    registerDiffFilesTool(server, options);
-    registerApplyPatchTool(server, options);
-    registerSearchAndReplaceTool(server, options);
+    for (const registerTool of TOOL_REGISTRARS) {
+        registerTool(server, options);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "MCP Server that enables LLMs to interact with the local filesystem.",
   "type": "module",
@@ -71,21 +71,20 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.0.0",
     "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/node": "^24",
-    "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-de-morgan": "^2.0.0",
     "eslint-plugin-depend": "^1.4.0",
-    "eslint-plugin-sonarjs": "^3.0.6",
-    "eslint-plugin-unused-imports": "^4.3.0",
+    "eslint-plugin-unused-imports": "^4.4.1",
     "jscpd": "^4.0.8",
-    "knip": "^5.83.1",
+    "knip": "^5.84.1",
     "prettier": "^3.8.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0"
+    "typescript-eslint": "^8.56.0"
   },
   "engines": {
     "node": ">=24"