@j0hanz/todokit-mcp 1.1.0 → 1.2.0

package/README.md

@@ -64,7 +64,7 @@ npm start
 
 ### Storage path
 
-By default, todos are stored in `todos.json` next to the server package (the project root when running from source). To control where data is written, set the `TODOKIT_TODO_FILE` environment variable to an absolute or relative path ending with `.json`. Relative paths resolve from the current working directory. The directory is created as needed; if the file does not exist, the server starts with an empty list.
+By default, todos are stored in `todos.json` in the current working directory. To control where data is written, set the `TODOKIT_TODO_FILE` environment variable to an absolute or relative path ending with `.json`. Relative paths resolve from the current working directory. The directory is created as needed; if the file does not exist, the server starts with an empty list.
 
 Examples:
 
@@ -227,7 +227,7 @@ Result fields:
 - `summary`
 - `nextActions`
 
-### delete_todos
+### clear_todos
 
 Delete all todos from the list.
 

package/dist/diagnostics.d.ts

@@ -24,6 +24,8 @@ export interface StorageEvent {
     v: 1;
     kind: 'storage';
     op: 'read' | 'write' | 'close';
+    requestId?: string | undefined;
+    tool?: string | undefined;
     at: string;
     durationMs?: number | undefined;
     cacheHit?: boolean | undefined;

package/dist/diagnostics.js

@@ -1,5 +1,6 @@
 import { channel, subscribe, unsubscribe, } from 'node:diagnostics_channel';
 import { performance } from 'node:perf_hooks';
+import { getRequestContext } from './requestContext.js';
 const toolDiagnosticsChannel = channel('todokit:tool');
 const storageDiagnosticsChannel = channel('todokit:storage');
 const lifecycleDiagnosticsChannel = channel('todokit:lifecycle');
@@ -54,6 +55,15 @@ export function publishToolResult(event) {
     safePublish(toolDiagnosticsChannel, event);
 }
 export function publishStorageEvent(event) {
+    const context = getRequestContext();
+    if (context) {
+        safePublish(storageDiagnosticsChannel, {
+            ...event,
+            requestId: event.requestId ?? context.requestId,
+            tool: event.tool ?? context.tool,
+        });
+        return;
+    }
     safePublish(storageDiagnosticsChannel, event);
 }
 export function publishLifecycleEvent(event) {

package/dist/index.js

@@ -3,7 +3,7 @@ import { pathToFileURL } from 'node:url';
 import { parseArgs } from 'node:util';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ErrorCode, InitializeRequestSchema, McpError, SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
+import {} from '@modelcontextprotocol/sdk/types.js';
 import packageJson from '../package.json' with { type: 'json' };
 import { enableDefaultDiagnosticsSubscribers, publishLifecycleEvent, } from './diagnostics.js';
 import { closeDb } from './storage.js';
@@ -99,9 +99,13 @@ let disableDiagnostics = null;
 function mapToolErrorCode(message) {
     if (message.startsWith('Input validation error'))
         return 'E_INVALID_PARAMS';
-    if (message.includes('not found'))
+    if (message.startsWith('Invalid tools/call request'))
+        return 'E_INVALID_PARAMS';
+    if (message.startsWith('Invalid task creation result'))
+        return 'E_OUTPUT_INVALID';
+    if (message.startsWith('Tool ') && message.includes(' not found'))
         return 'E_TOOL_NOT_FOUND';
-    if (message.includes('disabled'))
+    if (message.startsWith('Tool ') && message.includes(' disabled'))
         return 'E_TOOL_DISABLED';
     if (message.startsWith('Output validation error'))
         return 'E_OUTPUT_INVALID';
@@ -109,38 +113,40 @@ function mapToolErrorCode(message) {
 }
 function patchToolErrorResponses(server) {
     const target = server;
-    target.createToolError = (message) => {
-        const structured = {
-            ok: false,
-            error: { code: mapToolErrorCode(message), message },
-        };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(structured) }],
-            structuredContent: structured,
-            isError: true,
-        };
-    };
-}
-function enforceProtocolVersion(server) {
-    const internalServer = server.server;
-    const onInitialize = internalServer._oninitialize;
-    if (!onInitialize)
+    if (typeof target.createToolError !== 'function') {
         return;
-    const boundOnInitialize = onInitialize.bind(server.server);
-    internalServer.setRequestHandler(InitializeRequestSchema, (request) => {
-        const requested = request.params.protocolVersion;
-        if (!SUPPORTED_PROTOCOL_VERSIONS.includes(requested)) {
-            throw new McpError(ErrorCode.InvalidParams, `Unsupported protocol version: ${requested}`);
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(target, 'createToolError');
+    if (descriptor) {
+        if (descriptor.writable === false && descriptor.set === undefined) {
+            return;
         }
-        return boundOnInitialize(request);
-    });
+    }
+    if (!Object.isExtensible(target)) {
+        return;
+    }
+    try {
+        target.createToolError = (message) => {
+            const structured = {
+                ok: false,
+                error: { code: mapToolErrorCode(message), message },
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(structured) }],
+                structuredContent: structured,
+                isError: true,
+            };
+        };
+    }
+    catch {
+        // Best-effort override; fall back to SDK defaults if not writable.
+    }
 }
 export function createServer() {
     const server = new McpServer({ name: 'todokit', version: SERVER_VERSION }, {
         instructions: 'Todokit to-do list manager',
         capabilities: { logging: {} },
     });
-    enforceProtocolVersion(server);
     patchToolErrorResponses(server);
     registerAllTools(server);
     return server;
@@ -214,7 +220,7 @@ if (entrypoint && import.meta.url === pathToFileURL(entrypoint).href) {
         const logger = createStderrLogger(cli.logLevel);
         disableDiagnostics = enableDefaultDiagnosticsSubscribers({
             logger: (line) => {
-                logger.debug(line);
+                logger.info(line);
             },
         });
     }

package/dist/requestContext.d.ts

@@ -0,0 +1,6 @@
+export interface RequestContext {
+    requestId: string;
+    tool: string;
+}
+export declare function runWithRequestContext<T>(context: RequestContext, fn: () => T): T;
+export declare function getRequestContext(): RequestContext | undefined;

package/dist/requestContext.js

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const requestContextStorage = new AsyncLocalStorage();
+export function runWithRequestContext(context, fn) {
+    return requestContextStorage.run(context, fn);
+}
+export function getRequestContext() {
+    return requestContextStorage.getStore();
+}

package/dist/schema.js

@@ -80,5 +80,5 @@ export const ListTodosFilterSchema = z.strictObject({
 export const DefaultOutputSchema = z.strictObject({
     ok: z.boolean(),
     result: z.unknown().optional(),
-    error: z.object({ code: z.string(), message: z.string() }).optional(),
+    error: z.strictObject({ code: z.string(), message: z.string() }).optional(),
 });

package/dist/storage.d.ts

@@ -5,6 +5,7 @@ export declare function isAbortError(error: unknown): boolean;
 export declare function getFileMtime(path: string, timeoutMs: number): Promise<number | null>;
 export declare function readFileIfExists(path: string, timeoutMs: number, signal?: AbortSignal): Promise<string | null>;
 export declare function writeFileAtomic(path: string, contents: string, timeoutMs: number): Promise<number>;
+export declare function getCodedErrorCode(error: unknown): string | undefined;
 export declare function readTodos(): Promise<readonly Todo[]>;
 export declare function withTodos<T>(mutate: (todos: Todo[]) => {
     todos: Todo[];

package/dist/storage.js

@@ -1,7 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
 import { nowMs, publishStorageEvent } from './diagnostics.js';
 import { createErrorResponse } from './responses.js';
 import { TodosSchema } from './schema.js';
@@ -60,6 +59,17 @@ export async function getFileMtime(path, timeoutMs) {
         throw error;
     }
 }
+async function getFileSize(path, timeoutMs) {
+    try {
+        const stats = await withTimeout(stat(path), timeoutMs, 'File stat timed out');
+        return stats.size;
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return null;
+        throw error;
+    }
+}
 export async function readFileIfExists(path, timeoutMs, signal) {
     try {
         return await readFile(path, {
@@ -121,10 +131,42 @@ export async function writeFileAtomic(path, contents, timeoutMs) {
         await rm(tempPath, { force: true }).catch(() => undefined);
     }
 }
-const moduleDir = dirname(fileURLToPath(import.meta.url));
-const DEFAULT_TODO_FILE = join(moduleDir, '../todos.json');
+const DEFAULT_TODO_FILE = resolve(process.cwd(), 'todos.json');
 const IO_TIMEOUT_MS = 10_000;
 const WRITE_TIMEOUT_MS = 30_000;
+const LOCK_TIMEOUT_MS = 5_000;
+const DEFAULT_MAX_TODO_FILE_BYTES = 5 * 1024 * 1024;
+const MAX_CONFLICT_RETRIES = 3;
+class StorageError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'StorageError';
+        this.code = code;
+    }
+}
+function createCodedError(code, message) {
+    return new StorageError(code, message);
+}
+export function getCodedErrorCode(error) {
+    return error instanceof StorageError ? error.code : undefined;
+}
+function getEnvInt(name) {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return null;
+    const value = Number(raw);
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+        return null;
+    }
+    return value;
+}
+function getLockTimeoutMs() {
+    return getEnvInt('TODOKIT_LOCK_TIMEOUT_MS') ?? LOCK_TIMEOUT_MS;
+}
+function getMaxTodoFileBytes() {
+    return (getEnvInt('TODOKIT_MAX_TODO_FILE_BYTES') ?? DEFAULT_MAX_TODO_FILE_BYTES);
+}
 function getJsonIndentation() {
     const raw = process.env.TODOKIT_JSON_PRETTY?.trim().toLowerCase();
     if (!raw)
@@ -147,7 +189,38 @@ function enqueueWrite(task) {
     writeQueue = run.then(() => undefined, () => undefined);
     return run;
 }
+async function acquireWriteLock(todoPath, timeoutMs) {
+    const lockPath = `${todoPath}.lock`;
+    const started = nowMs();
+    await mkdir(dirname(todoPath), { recursive: true });
+    for (;;) {
+        try {
+            await writeFile(lockPath, `${String(process.pid)} ${new Date().toISOString()}\n`, { encoding: 'utf8', flag: 'wx' });
+            return async () => {
+                await rm(lockPath, { force: true }).catch(() => undefined);
+            };
+        }
+        catch (error) {
+            const code = getErrorCode(error);
+            if (code !== 'EEXIST') {
+                throw error;
+            }
+            const elapsedMs = Math.max(0, nowMs() - started);
+            if (elapsedMs >= timeoutMs) {
+                throw createCodedError('E_STORAGE_LOCK_TIMEOUT', 'Todo storage is busy; please retry.');
+            }
+            await delay(25);
+        }
+    }
+}
 async function loadTodos(path) {
+    const size = await getFileSize(path, IO_TIMEOUT_MS);
+    if (size !== null) {
+        const maxBytes = getMaxTodoFileBytes();
+        if (size > maxBytes) {
+            throw createCodedError('E_STORAGE_TOO_LARGE', `Todo storage file is too large (${String(size)} bytes; max ${String(maxBytes)}).`);
+        }
+    }
     const raw = await readFileIfExists(path, IO_TIMEOUT_MS);
     if (!raw)
         return [];
@@ -207,14 +280,31 @@ export async function readTodos() {
 export async function withTodos(mutate) {
     return enqueueWrite(async () => {
         const path = getTodoFilePath();
-        const mtimeMs = await getFileMtime(path, IO_TIMEOUT_MS);
-        const current = cache?.mtimeMs === mtimeMs ? cache.todos : await loadTodos(path);
-        cache = { todos: current, mtimeMs };
-        const { todos, result } = mutate(current);
-        if (todos !== current) {
-            await saveTodos(path, todos);
+        for (let attempt = 0; attempt <= MAX_CONFLICT_RETRIES; attempt += 1) {
+            const mtimeMs = await getFileMtime(path, IO_TIMEOUT_MS);
+            const current = cache?.mtimeMs === mtimeMs ? cache.todos : await loadTodos(path);
+            cache = { todos: current, mtimeMs };
+            const { todos, result } = mutate(current);
+            if (todos !== current) {
+                const release = await acquireWriteLock(path, getLockTimeoutMs());
+                try {
+                    const latestMtime = await getFileMtime(path, IO_TIMEOUT_MS);
+                    if (latestMtime !== mtimeMs) {
+                        if (attempt >= MAX_CONFLICT_RETRIES) {
+                            throw createCodedError('E_STORAGE_CONFLICT', 'Todo storage changed during update; please retry.');
+                        }
+                        await delay(25 * (attempt + 1));
+                        continue;
+                    }
+                    await saveTodos(path, todos);
+                }
+                finally {
+                    await release();
+                }
+            }
+            return result;
         }
-        return result;
+        throw createCodedError('E_STORAGE_CONFLICT', 'Todo storage update failed due to concurrent modifications');
     });
 }
 export async function closeDb() {
@@ -230,17 +320,23 @@ export async function closeDb() {
         durationMs: Math.max(0, nowMs() - start),
     });
 }
-function matchesCompleted(todo, completed) {
-    return completed === undefined || todo.completed === completed;
-}
-function matchesQuery(todo, query) {
-    if (!query)
-        return true;
-    return todo.description.toLowerCase().includes(query);
-}
 export function filterTodos(todos, filters) {
-    const query = filters.query?.trim().toLowerCase();
-    return todos.filter((todo) => matchesCompleted(todo, filters.completed) && matchesQuery(todo, query));
+    const { completed, query: rawQuery } = filters;
+    const hasCompletedFilter = completed !== undefined;
+    const trimmedQuery = rawQuery?.trim();
+    const query = trimmedQuery?.toLowerCase();
+    if (!hasCompletedFilter && !query) {
+        return todos;
+    }
+    const matches = [];
+    for (const todo of todos) {
+        if (hasCompletedFilter && todo.completed !== completed)
+            continue;
+        if (query && !todo.description.toLowerCase().includes(query))
+            continue;
+        matches.push(todo);
+    }
+    return matches;
 }
 const PREVIEW_LIMIT = 5;
 function buildMatchPreviews(todos, limit = PREVIEW_LIMIT) {
@@ -455,10 +551,16 @@ export async function completeTodoBySelector(input, completed) {
 export function deleteTodosByIds(ids) {
     const idsToDelete = new Set(ids);
     return withTodos((todos) => {
-        const remaining = todos.filter((todo) => !idsToDelete.has(todo.id));
-        const deletedIds = todos
-            .filter((todo) => idsToDelete.has(todo.id))
-            .map((todo) => todo.id);
+        const remaining = [];
+        const deletedIds = [];
+        for (const todo of todos) {
+            if (idsToDelete.has(todo.id)) {
+                deletedIds.push(todo.id);
+            }
+            else {
+                remaining.push(todo);
+            }
+        }
         return { todos: remaining, result: deletedIds };
     });
 }

package/dist/tools.d.ts

@@ -16,6 +16,6 @@ export declare function registerListTodos(server: McpServer): void;
 export declare function registerUpdateTodo(server: McpServer): void;
 export declare function registerCompleteTodo(server: McpServer): void;
 export declare function registerDeleteTodo(server: McpServer): void;
-export declare function registerDeleteTodos(server: McpServer): void;
+export declare function registerClearTodos(server: McpServer): void;
 export declare function registerAllTools(server: McpServer): void;
 export {};

package/dist/tools.js

@@ -1,9 +1,17 @@
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
 import { nowMs, publishToolCallWithId, publishToolResult, } from './diagnostics.js';
+import { runWithRequestContext } from './requestContext.js';
 import { createErrorResponse, createToolResponse, getErrorMessage, } from './responses.js';
 import { AddTodoSchema, AddTodosSchema, CompleteTodoSchema, DefaultOutputSchema, DeleteTodoSchema, ListTodosFilterSchema, UpdateTodoSchema, } from './schema.js';
-import { addTodos, completeTodoBySelector, deleteAllTodos, deleteTodoBySelector, getTodos, toResolveInput, updateTodoBySelector, } from './storage.js';
+import { addTodos, completeTodoBySelector, deleteAllTodos, deleteTodoBySelector, getCodedErrorCode, getTodos, toResolveInput, updateTodoBySelector, } from './storage.js';
+function mapExecutionError(error, fallbackCode) {
+    const coded = getCodedErrorCode(error);
+    if (coded) {
+        return { code: coded, message: getErrorMessage(error) };
+    }
+    return { code: fallbackCode, message: getErrorMessage(error) };
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
@@ -49,7 +57,15 @@ function createWrappedHandler(tool, handler) {
         const requestId = randomUUID();
         publishToolCallWithId(tool, input, requestId);
         const start = nowMs();
-        const result = handler(input, extra);
+        let result;
+        try {
+            result = runWithRequestContext({ requestId, tool }, () => handler(input, extra));
+        }
+        catch (error) {
+            publishFailureResult(tool, requestId, start);
+            const rejection = error instanceof Error ? error : new Error(String(error));
+            return Promise.reject(rejection);
+        }
         return Promise.resolve(result)
             .then((resolved) => {
             publishSuccessResult(tool, requestId, start, resolved);
@@ -114,7 +130,8 @@ async function handleAddTodo(input) {
         return buildAddTodoResponse(requireSingleTodo(todos));
     }
     catch (err) {
-        return createErrorResponse('E_ADD_TODO', getErrorMessage(err));
+        const mapped = mapExecutionError(err, 'E_ADD_TODO');
+        return createErrorResponse(mapped.code, mapped.message);
     }
 }
 export function registerAddTodo(server) {
@@ -136,14 +153,19 @@ async function handleAddTodos(input) {
         return buildAddTodosResponse(todos);
     }
     catch (err) {
-        return createErrorResponse('E_ADD_TODOS', getErrorMessage(err));
+        const mapped = mapExecutionError(err, 'E_ADD_TODOS');
+        return createErrorResponse(mapped.code, mapped.message);
     }
 }
 export function registerAddTodos(server) {
     registerToolWithDiagnostics(server, 'add_todos', addTodosToolConfig, handleAddTodos);
 }
 function computeCounts(todos) {
-    const completed = todos.filter((t) => t.completed).length;
+    let completed = 0;
+    for (const todo of todos) {
+        if (todo.completed)
+            completed += 1;
+    }
     return {
         total: todos.length,
         completed,
@@ -198,7 +220,8 @@ export function registerListTodos(server) {
             return await handleListTodos(filters);
         }
         catch (err) {
-            return createErrorResponse('E_LIST_TODOS', getErrorMessage(err));
+            const mapped = mapExecutionError(err, 'E_LIST_TODOS');
+            return createErrorResponse(mapped.code, mapped.message);
         }
     });
 }
@@ -240,7 +263,8 @@ export function registerUpdateTodo(server) {
             return await handleUpdateTodo(input);
         }
         catch (err) {
-            return createErrorResponse('E_UPDATE_TODO', getErrorMessage(err));
+            const mapped = mapExecutionError(err, 'E_UPDATE_TODO');
+            return createErrorResponse(mapped.code, mapped.message);
         }
     });
 }
@@ -287,7 +311,8 @@ export function registerCompleteTodo(server) {
             return await handleCompleteTodo(input);
         }
         catch (err) {
-            return createErrorResponse('E_COMPLETE_TODO', getErrorMessage(err));
+            const mapped = mapExecutionError(err, 'E_COMPLETE_TODO');
+            return createErrorResponse(mapped.code, mapped.message);
         }
     });
 }
@@ -316,7 +341,7 @@ export function registerDeleteTodo(server) {
         outputSchema: DefaultOutputSchema,
         annotations: {
             readOnlyHint: false,
-            idempotentHint: true,
+            idempotentHint: false,
             destructiveHint: true,
         },
     }, async (input) => {
@@ -324,7 +349,8 @@ export function registerDeleteTodo(server) {
             return await handleDeleteTodo(input);
         }
         catch (err) {
-            return createErrorResponse('E_DELETE_TODO', getErrorMessage(err));
+            const mapped = mapExecutionError(err, 'E_DELETE_TODO');
+            return createErrorResponse(mapped.code, mapped.message);
         }
     });
 }
@@ -341,11 +367,11 @@ async function handleDeleteTodos() {
         },
     });
 }
-export function registerDeleteTodos(server) {
-    registerToolWithDiagnostics(server, 'delete_todos', {
-        title: 'Delete All Todos',
+export function registerClearTodos(server) {
+    registerToolWithDiagnostics(server, 'clear_todos', {
+        title: 'Clear All Todos',
         description: 'Delete all todos from the list',
-        inputSchema: z.object({}),
+        inputSchema: z.strictObject({}),
         outputSchema: DefaultOutputSchema,
         annotations: {
             readOnlyHint: false,
@@ -357,7 +383,8 @@ export function registerDeleteTodos(server) {
             return await handleDeleteTodos();
         }
         catch (err) {
-            return createErrorResponse('E_DELETE_TODOS', getErrorMessage(err));
+            const mapped = mapExecutionError(err, 'E_CLEAR_TODOS');
+            return createErrorResponse(mapped.code, mapped.message);
         }
     });
 }
@@ -368,7 +395,7 @@ const TOOL_REGISTRATIONS = [
     registerUpdateTodo,
     registerCompleteTodo,
     registerDeleteTodo,
-    registerDeleteTodos,
+    registerClearTodos,
 ];
 export function registerAllTools(server) {
     TOOL_REGISTRATIONS.forEach((register) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/todokit-mcp",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "mcpName": "io.github.j0hanz/todokit",
   "description": "A MCP server for Todokit, a task management and productivity tool with JSON storage.",
   "type": "module",
@@ -64,7 +64,7 @@
     "eslint-plugin-sonarjs": "^3.0.5",
     "eslint-plugin-unused-imports": "^4.3.0",
     "knip": "^5.80.2",
-    "jscpd": "4.0.5",
+    "jscpd": "4.0.7",
     "prettier": "^3.7.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",