@j0hanz/filesystem-mcp 1.17.0 → 1.18.0

package/dist/tools/shared.js

@@ -3,7 +3,7 @@ import { basename } from 'node:path';
 import { z } from 'zod';
 import { createTimedAbortSignal } from '../lib/abort.js';
 import { parseTrueEnvFlag } from '../lib/constants.js';
-import { createDetailedError, ErrorCode, formatDetailedError, getSuggestion, McpError, } from '../lib/errors.js';
+import { classifyError, createDetailedError, ErrorCode, formatDetailedError, getSuggestion, McpError, } from '../lib/errors.js';
 import { Logger } from '../lib/logger.js';
 import { withToolDiagnostics, } from '../lib/observability.js';
 import { getAllowedDirectories } from '../lib/paths.js';
@@ -223,20 +223,18 @@ export function withValidatedArgs(schema, handler) {
         }
     };
 }
-function toToolContext(ctx) {
+export function toToolContext(ctx) {
     if (!ctx)
         return {};
     if ('mcpReq' in ctx) {
         return {
             signal: ctx.mcpReq.signal,
+            ...(ctx.sessionId ? { sessionId: ctx.sessionId } : {}),
             ...(ctx.mcpReq._meta
                 ? { _meta: ctx.mcpReq._meta }
                 : {}),
             sendNotification: async (notification) => ctx.mcpReq.notify(notification),
-            log: async (level, data, logger) => ctx.mcpReq.notify({
-                method: 'notifications/message',
-                params: { level, data, ...(logger ? { logger } : {}) },
-            }),
+            log: async (level, data, logger) => ctx.mcpReq.log(level, data, logger),
         };
     }
     return ctx;
@@ -509,7 +507,7 @@ async function withProgress(message, ctx, run, getCompletionMessage) {
         void reportProgress(ctx, {
             current: total,
             total,
-            message: `${message} • failed`,
+            message: `${message} • ${classifyError(error)}`,
         });
         throw error;
     }
@@ -599,13 +597,3 @@ export function truncateProgressPattern(pattern, maxLength = 40) {
     }
     return `${pattern.slice(0, maxLength)}…`;
 }
-export function buildBatchCompletionSuffix(summary, successWord, singularWord) {
-    const total = summary?.total ?? 0;
-    const failed = summary?.failed ?? 0;
-    const succeeded = summary?.succeeded ?? 0;
-    if (failed) {
-        return `${succeeded}/${total} ${successWord}, ${failed} failed`;
-    }
-    const word = total === 1 && singularWord ? singularWord : successWord;
-    return `${total} ${word}`;
-}

package/dist/tools/stat-many.js

@@ -1,10 +1,10 @@
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
-import { ErrorCode } from '../lib/errors.js';
+import { classifyError, ErrorCode } from '../lib/errors.js';
 import { getMultipleFileInfo } from '../lib/file-operations/metadata.js';
 import { formatBytes, joinLines } from '../config.js';
 import { GetMultipleFileInfoInputSchema, GetMultipleFileInfoOutputSchema, } from '../schemas.js';
 import { FILE_READ_ICONS } from './icons.js';
-import { buildBatchCompletionSuffix, buildBatchPathContext, buildFileInfoPayload, buildStructuredError, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, } from './shared.js';
+import { buildBatchPathContext, buildFileInfoPayload, buildStructuredError, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, } from './shared.js';
 import { registerStandardTool } from './task-support.js';
 export const GET_MULTIPLE_FILE_INFO_TOOL = {
     name: 'stat_many',
@@ -77,7 +77,7 @@ export function registerGetMultipleFileInfoTool(server, options = {}) {
             run: async (signal) => {
                 const context = buildBatchPathContext(args.paths);
                 const { progress, onItemComplete } = createBatchProgressCallbacks(ctx, {
-                    toolLabel: '🕮 stat_many',
+                    toolLabel: GET_MULTIPLE_FILE_INFO_TOOL.title,
                     context,
                     totalItems: args.paths.length,
                     itemVerb: 'done',
@@ -85,14 +85,15 @@ export function registerGetMultipleFileInfoTool(server, options = {}) {
                 try {
                     const result = await handleGetMultipleFileInfo(args, signal, onItemComplete);
                     const sc = result.structuredContent;
-                    const suffix = buildBatchCompletionSuffix(sc.summary, 'OK');
                     const total = sc.summary?.total ?? 0;
+                    const failed = sc.summary?.failed ?? 0;
+                    const suffix = failed ? `${failed} failed` : 'done';
                     const finalCurrent = resolveFinalProgressCurrent(progress, total);
-                    progress.complete(`🕮 stat_many: ${context} • ${suffix}`, finalCurrent);
+                    progress.complete(`${GET_MULTIPLE_FILE_INFO_TOOL.title}: ${context} • ${suffix}`, finalCurrent);
                     return result;
                 }
                 catch (error) {
-                    progress.fail(`🕮 stat_many: ${context} • failed`);
+                    progress.fail(`${GET_MULTIPLE_FILE_INFO_TOOL.title}: ${context} • ${classifyError(error)}`);
                     throw error;
                 }
             },

package/dist/tools/stat.js

@@ -53,15 +53,15 @@ export function registerGetFileInfoTool(server, options = {}) {
         onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_FOUND, args.path),
     });
     registerStandardTool(server, GET_FILE_INFO_TOOL, handler, options, {
-        progressMessage: (args) => `🕮 stat: ${basename(args.path)}`,
+        progressMessage: (args) => `${GET_FILE_INFO_TOOL.title}: ${basename(args.path)}`,
         completionMessage: (args, result) => {
             const name = basename(args.path);
             if (result.isError)
-                return `🕮 stat: ${name} • failed`;
+                return `${GET_FILE_INFO_TOOL.title}: ${name} • ${result.errorCode}`;
             const sc = result.structuredContent;
             if (!sc.info)
-                return `🕮 stat: ${name} • failed`;
-            return `🕮 stat: ${sc.info.name} • ${sc.info.type}, ${formatBytes(sc.info.size)}`;
+                return `${GET_FILE_INFO_TOOL.title}: ${name} • failed`;
+            return `${GET_FILE_INFO_TOOL.title}: ${sc.info.name} • ${formatBytes(sc.info.size)}`;
         },
     });
 }

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

@@ -1,5 +1,10 @@
 import { type McpServer, type RequestTaskStore, type StandardSchemaWithJSON, type ToolTaskHandler } from '@modelcontextprotocol/server';
 import { type IconInfo, type ToolContext, type ToolContract, type ToolRegistrationOptions, type ToolResult } from './shared.js';
+/**
+ * Report an intermediate 'working' status update for the current task.
+ * No-op when called outside of a task context.
+ */
+export declare function reportTaskStatus(statusMessage: string): Promise<void>;
 type TaskToolContext = ToolContext & {
     taskId?: string;
     taskStore?: RequestTaskStore;

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,19 +214,26 @@ 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();
+    let release;
+    const next = new Promise((resolve) => {
+        release = resolve;
+    });
+    taskCreationLocks.set(taskStore, previous.catch(() => { }).then(() => next));
+    await previous.catch(() => { });
+    return () => {
+        release();
+    };
+}
 async function isTaskAlreadyTerminal(taskStore, taskId) {
     try {
         const task = await taskStore.getTask(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;
@@ -288,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;
         }
     }
@@ -344,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)
@@ -379,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),
                 });
@@ -438,18 +401,26 @@ 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');
         }
         const taskStore = getTaskStore(ctx);
-        if ((await countActiveTasks(taskStore)) >= MAX_CONCURRENT_TASKS) {
-            throw new McpError(ErrorCode.INVALID_INPUT, `Too many active tasks (limit: ${String(MAX_CONCURRENT_TASKS)}).`);
+        const releaseCreationLock = await acquireTaskCreationLock(taskStore);
+        let task;
+        try {
+            if ((await countActiveTasks(taskStore)) >= MAX_CONCURRENT_TASKS) {
+                throw new McpError(ErrorCode.INVALID_INPUT, `Too many active tasks (limit: ${String(MAX_CONCURRENT_TASKS)}).`);
+            }
+            task = await taskStore.createTask({
+                ttl: resolveRequestedTaskTtl(ctx.taskRequestedTtl),
+                pollInterval: options?.pollIntervalMs ?? TASK_POLL_INTERVAL_MS,
+            });
+        }
+        finally {
+            releaseCreationLock();
         }
-        const task = await taskStore.createTask({
-            ttl: resolveRequestedTaskTtl(ctx.taskRequestedTtl),
-            pollInterval: options?.pollIntervalMs ?? TASK_POLL_INTERVAL_MS,
-        });
         const toolLabel = options?.toolName ?? 'tool';
         try {
             await taskStore.updateTaskStatus(task.taskId, 'working', `${toolLabel}: starting`);
@@ -473,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.0",
+  "version": "1.18.0",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "Secure filesystem MCP server for reading, writing, searching, diffing, and patching files.",
   "author": "j0hanz",