@j0hanz/filesystem-mcp 1.13.2 → 1.14.1

package/dist/server/bootstrap.d.ts

@@ -1,14 +1,15 @@
-import * as http from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
-export interface ServerOptions {
-    allowCwd?: boolean;
-    cliAllowedDirs?: string[];
-}
-export interface LoggingState {
-    minimumLevel: LoggingLevel;
-}
-export declare function logToMcp(server: McpServer | undefined, level: LoggingLevel, data: string, minLevel?: LoggingLevel): void;
+import { type Server } from 'node:http';
+import { type LoggingState } from '../lib/logger.js';
+import { type ServerOptions } from './roots-manager.js';
+export declare const activeServers: Map<string, {
+    server: McpServer;
+    loggingState: LoggingState;
+}>;
+export declare let stdioServer: {
+    server: McpServer;
+    loggingState: LoggingState;
+} | undefined;
 export declare function createServer(options?: ServerOptions): Promise<McpServer>;
 export declare function startServer(server: McpServer): Promise<void>;
-export declare function startHttpServer(port: number, options: ServerOptions): Promise<http.Server>;
+export declare function startHttpServer(port: number, options: ServerOptions): Promise<Server>;

package/dist/server/bootstrap.js

@@ -1,16 +1,17 @@
-import * as fs from 'node:fs/promises';
-import * as http from 'node:http';
-import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
-import { InMemoryTaskMessageQueue, InMemoryTaskStore, } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
+import { InMemoryTaskMessageQueue } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest, LATEST_PROTOCOL_VERSION, SetLevelRequestSchema, SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
+import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
+import { channel } from 'node:diagnostics_channel';
+import { readFile } from 'node:fs/promises';
+import { createServer as createHttpServer, } from 'node:http';
 import { DEFAULT_LOG_LEVEL, parseEnvInt } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
+import { createLoggingState, Logger, logToMcp, SessionContext, } from '../lib/logger.js';
 import { withAllowedDirectoriesState } from '../lib/paths.js';
 import { createInMemoryResourceStore } from '../lib/resource-store.js';
-import { isRecord } from '../lib/utils.js';
 import { registerCompletions } from '../completions.js';
 import { pkgInfo } from '../pkg-info.js';
 import { registerAnalyzePathPrompt, registerCompareFilesPrompt, registerGetHelpPrompt, registerGetToolHelpPrompt, } from '../prompts.js';
@@ -19,6 +20,7 @@ import { buildServerInstructions } from '../resources/generated-instructions.js'
 import { registerAllTools } from '../tools.js';
 import { withDefaultIcons } from '../tools/shared.js';
 import { RootsManager } from './roots-manager.js';
+import { createTaskStore } from './task-store.js';
 let cachedTaskToolSupport;
 function detectTaskToolSupport() {
     if (cachedTaskToolSupport !== undefined) {
@@ -48,6 +50,7 @@ function buildServerCapabilities(options = {}) {
         tools: {},
         prompts: options.enablePromptListChanged ? { listChanged: true } : {},
         completions: {},
+        extensions: {},
     };
     if (options.enableTaskToolRequests) {
         // NOTE: enabling task tool requests requires the caller to configure
@@ -64,45 +67,30 @@ function buildServerCapabilities(options = {}) {
 function supportsTaskToolRequests() {
     return detectTaskToolSupport();
 }
-const MCP_LOGGER_NAME = 'filesystem-mcp';
-const LOG_LEVEL_ORDER = {
-    debug: 0,
-    info: 1,
-    notice: 2,
-    warning: 3,
-    error: 4,
-    critical: 5,
-    alert: 6,
-    emergency: 7,
-};
-function createLoggingState(minimumLevel = 'debug') {
-    return { minimumLevel };
-}
-function canSendMcpLogs(server) {
-    const capabilities = server.server.getClientCapabilities();
-    if (!isRecord(capabilities))
-        return false;
-    if (!('logging' in capabilities))
-        return false;
-    return !!capabilities['logging'];
+// Global map of all active servers by sessionId for routing logs
+export const activeServers = new Map();
+// For stdio (single session without a specific ID)
+export let stdioServer;
+function stringifyData(data) {
+    if (!data)
+        return '';
+    return ` ${typeof data === 'string' ? data : JSON.stringify(data)}`;
 }
-export function logToMcp(server, level, data, minLevel = 'debug') {
-    if (LOG_LEVEL_ORDER[level] < LOG_LEVEL_ORDER[minLevel]) {
-        return;
+channel('filesystem-mcp:log').subscribe((message) => {
+    const event = message;
+    const target = event.sessionId
+        ? activeServers.get(event.sessionId)
+        : stdioServer;
+    const dataStr = stringifyData(event.data);
+    if (target) {
+        logToMcp(target.server, event.level, `${event.message}${dataStr}`, target.loggingState.minimumLevel);
     }
-    if (!server || !canSendMcpLogs(server)) {
-        console.error(data);
-        return;
+    else {
+        // Fallback if no server
+        const fullMsg = `${event.message}${dataStr}`;
+        console.error(`[${event.level.toUpperCase()}] ${fullMsg}`);
     }
-    const params = {
-        level,
-        logger: MCP_LOGGER_NAME,
-        data,
-    };
-    void server.sendLoggingMessage(params).catch((error) => {
-        console.error(`Failed to send MCP log: ${level} | ${data}`, formatUnknownErrorMessage(error));
-    });
-}
+});
 const { version: SERVER_VERSION, description: SERVER_DESCRIPTION, homepage: SERVER_HOMEPAGE, } = pkgInfo;
 const rootsManagers = new WeakMap();
 function getRootsManager(server) {
@@ -119,7 +107,7 @@ async function getLocalIconInfo() {
     for (const candidate of candidates) {
         try {
             const iconPath = new URL(candidate, import.meta.url);
-            const buffer = await fs.readFile(iconPath);
+            const buffer = await readFile(iconPath);
             return {
                 src: `data:${mime};base64,${buffer.toString('base64')}`,
                 mimeType: mime,
@@ -144,7 +132,7 @@ export async function createServer(options = {}) {
     };
     if (taskToolSupport) {
         // Enabling task tool support requires configuring a task store and message queue on the server config. We use in-memory implementations from the SDK which auto-evict tasks after their TTL expires (via setTimeout). Suitable for both stdio and HTTP sessions.
-        serverConfig.taskStore = new InMemoryTaskStore();
+        serverConfig.taskStore = createTaskStore();
         serverConfig.taskMessageQueue = new InMemoryTaskMessageQueue();
     }
     if (serverInstructions) {
@@ -163,10 +151,15 @@ export async function createServer(options = {}) {
     const loggingState = createLoggingState(DEFAULT_LOG_LEVEL);
     const rootsManager = new RootsManager(options, loggingState);
     rootsManagers.set(server, rootsManager);
+    // Subscribe to Logger channel if not already done, but we need to route based on session or fallback to this server if it's stdio.
+    // Wait, in stdio there's only one server. In HTTP there are multiple.
     server.server.setRequestHandler(SetLevelRequestSchema, (req) => {
         loggingState.minimumLevel = req.params.level;
+        Logger.notice(`Log level set to ${req.params.level}`);
         return {};
     });
+    // Track stdio server by default, or it will be overwritten per HTTP session later
+    stdioServer ??= { server, loggingState };
     registerInstructionResource(server, serverInstructions, localIcon);
     registerToolCatalogResource(server, localIcon);
     registerWorkflowGuideResource(server, localIcon);
@@ -257,6 +250,10 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
                 transport,
                 negotiatedProtocolVersion,
             });
+            activeServers.set(sessionId, {
+                server: mcpServer,
+                loggingState: rootsManager['loggingState'],
+            });
             rootsManager.logMissingDirectoriesIfNeeded(mcpServer);
         },
     });
@@ -264,10 +261,11 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
         const { sessionId } = transport;
         if (sessionId) {
             sessions.delete(sessionId);
+            activeServers.delete(sessionId);
         }
         rootsManager.destroy();
         mcpServer.close().catch((err) => {
-            console.error('[HTTP] Error closing MCP server:', formatUnknownErrorMessage(err));
+            Logger.error('[HTTP] Error closing MCP server:', formatUnknownErrorMessage(err));
         });
     };
     await mcpServer.connect(transport);
@@ -368,7 +366,12 @@ function discardRequestBody(req) {
     req.resume();
 }
 async function handleSessionTransportRequest(session, req, res, body) {
-    await withAllowedDirectoriesState(session.rootsManager.getAllowedDirectoriesState(), () => session.transport.handleRequest(req, res, body));
+    const store = session.transport.sessionId
+        ? { sessionId: session.transport.sessionId }
+        : {};
+    await SessionContext.run(store, async () => {
+        await withAllowedDirectoriesState(session.rootsManager.getAllowedDirectoriesState(), () => session.transport.handleRequest(req, res, body));
+    });
 }
 function getSessionOrRespondNotFound(sessions, sessionId, res) {
     const session = sessions.get(sessionId);
@@ -396,6 +399,47 @@ export async function startHttpServer(port, options) {
     const sessions = new Map();
     const httpHost = process.env['FILESYSTEM_MCP_HTTP_HOST'] ?? '127.0.0.1';
     assertHttpBindingSecurity(httpHost);
+    async function handlePostRequest(req, res, sessionId) {
+        if (sessionId) {
+            const session = getSessionOrRespondNotFound(sessions, sessionId, res);
+            if (!session) {
+                discardRequestBody(req);
+                return;
+            }
+            if (!ensureSessionProtocolVersion(req, res, session)) {
+                discardRequestBody(req);
+                return;
+            }
+            const body = await readRequestBody(req);
+            await handleSessionTransportRequest(session, req, res, body);
+            return;
+        }
+        const body = await readRequestBody(req);
+        if (isInitializeRequest(body)) {
+            const maxSessions = parseEnvInt('FILESYSTEM_MCP_MAX_HTTP_SESSIONS', 100, 1, 10_000);
+            if (sessions.size >= maxSessions) {
+                sendJsonRpcError(res, 503, JSON_RPC_SERVER_ERROR, 'Too many sessions');
+                return;
+            }
+            const session = await createHttpSession(options, sessions, resolveNegotiatedProtocolVersion(body.params.protocolVersion));
+            await handleSessionTransportRequest(session, req, res, body);
+            return;
+        }
+        sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: No valid session ID provided');
+        discardRequestBody(req);
+    }
+    async function handleGetDeleteRequest(req, res, sessionId) {
+        if (!sessionId) {
+            sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: Missing session ID');
+            return;
+        }
+        const session = getSessionOrRespondNotFound(sessions, sessionId, res);
+        if (!session)
+            return;
+        if (!ensureSessionProtocolVersion(req, res, session))
+            return;
+        await handleSessionTransportRequest(session, req, res);
+    }
     async function handleMcpRequest(req, res) {
         const { method } = req;
         const sessionId = getSessionId(req);
@@ -408,45 +452,10 @@ export async function startHttpServer(port, options) {
             return;
         try {
             if (method === 'POST') {
-                if (sessionId) {
-                    const session = getSessionOrRespondNotFound(sessions, sessionId, res);
-                    if (!session) {
-                        discardRequestBody(req);
-                        return;
-                    }
-                    if (!ensureSessionProtocolVersion(req, res, session)) {
-                        discardRequestBody(req);
-                        return;
-                    }
-                    const body = await readRequestBody(req);
-                    await handleSessionTransportRequest(session, req, res, body);
-                    return;
-                }
-                const body = await readRequestBody(req);
-                if (isInitializeRequest(body)) {
-                    const maxSessions = parseEnvInt('FILESYSTEM_MCP_MAX_HTTP_SESSIONS', 100, 1, 10_000);
-                    if (sessions.size >= maxSessions) {
-                        sendJsonRpcError(res, 503, JSON_RPC_SERVER_ERROR, 'Too many sessions');
-                        return;
-                    }
-                    const session = await createHttpSession(options, sessions, resolveNegotiatedProtocolVersion(body.params.protocolVersion));
-                    await handleSessionTransportRequest(session, req, res, body);
-                    return;
-                }
-                sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: No valid session ID provided');
-                discardRequestBody(req);
+                await handlePostRequest(req, res, sessionId);
             }
             else if (method === 'GET' || method === 'DELETE') {
-                if (!sessionId) {
-                    sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: Missing session ID');
-                    return;
-                }
-                const session = getSessionOrRespondNotFound(sessions, sessionId, res);
-                if (!session)
-                    return;
-                if (!ensureSessionProtocolVersion(req, res, session))
-                    return;
-                await handleSessionTransportRequest(session, req, res);
+                await handleGetDeleteRequest(req, res, sessionId);
             }
             else {
                 res.writeHead(405, {
@@ -472,17 +481,17 @@ export async function startHttpServer(port, options) {
                 sendJsonRpcError(res, error.statusCode, rpcCode, error.message);
                 return;
             }
-            console.error('[HTTP] Error handling request:', formatUnknownErrorMessage(error));
+            Logger.error('[HTTP] Error handling request:', formatUnknownErrorMessage(error));
             if (!res.headersSent) {
                 sendJsonRpcError(res, 500, JSON_RPC_INTERNAL_ERROR, 'Internal Server Error');
             }
         }
     }
-    const httpServer = http.createServer((req, res) => {
+    const httpServer = createHttpServer((req, res) => {
         const urlPath = (req.url ?? '/').split('?')[0];
         if (urlPath === '/mcp') {
             handleMcpRequest(req, res).catch((err) => {
-                console.error('[HTTP] Unhandled error in request handler:', formatUnknownErrorMessage(err));
+                Logger.error('[HTTP] Unhandled error in request handler:', formatUnknownErrorMessage(err));
             });
         }
         else {
@@ -493,7 +502,7 @@ export async function startHttpServer(port, options) {
     return new Promise((resolve, reject) => {
         httpServer.once('error', reject);
         httpServer.listen(port, httpHost, () => {
-            console.error(`MCP HTTP server listening on ${httpHost}:${port}`);
+            Logger.info(`MCP HTTP server listening on ${httpHost}:${port}`);
             resolve(httpServer);
         });
     });

package/dist/server/roots-manager.d.ts

@@ -1,7 +1,10 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type LoggingState } from '../lib/logger.js';
 import { type AllowedDirectoriesState } from '../lib/paths.js';
-import { type LoggingState } from './bootstrap.js';
-import type { ServerOptions } from './bootstrap.js';
+export interface ServerOptions {
+    allowCwd?: boolean;
+    cliAllowedDirs?: string[];
+}
 export declare class RootsManager {
     private _debouncedUpdate;
     private rootDirectories;

package/dist/server/roots-manager.js

@@ -1,11 +1,11 @@
-import * as fs from 'node:fs/promises';
 import { InitializedNotificationSchema, RootsListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { realpath } from 'node:fs/promises';
 import { z } from 'zod';
+import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/abort.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
-import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
+import { Logger, logToMcp } from '../lib/logger.js';
 import { getValidRootDirectories, isPathWithinDirectories, normalizePath, resolveAllowedDirectoriesState, setAllowedDirectoriesStateResolved, } from '../lib/paths.js';
 import { debounce, isRecord } from '../lib/utils.js';
-import { logToMcp } from './bootstrap.js';
 const ROOTS_TIMEOUT_MS = 5000;
 const ROOTS_DEBOUNCE_MS = 100;
 function normalizeCLIDirectories(dirs) {
@@ -22,7 +22,7 @@ const RootSchema = z.strictObject({
     uri: z.string(),
     name: z.string().optional(),
 });
-const RootsResponseSchema = z.object({
+const RootsResponseSchema = z.strictObject({
     roots: z.array(RootSchema).optional(),
 });
 function isRoot(value) {
@@ -61,7 +61,7 @@ async function isRootWithinBaseline(normalizedRoot, baseline, signal) {
     }
     try {
         assertNotAborted(signal);
-        const realPath = await withAbort(fs.realpath(normalizedRoot), signal);
+        const realPath = await withAbort(realpath(normalizedRoot), signal);
         const normalizedReal = normalizePath(realPath);
         return isPathWithinDirectories(normalizedReal, baseline);
     }
@@ -88,9 +88,10 @@ export class RootsManager {
         expanded: [],
     };
     clientInitialized = false;
-    // Set to true when an update is in progress, to prevent concurrent executions. If a change arrives while true, we queue a single retry after completion to ensure the last-known state is applied. This
+    // Guard concurrent root refreshes; if one is already running we queue one
+    // replay so the last-known state still gets applied after completion.
     updatingRoots = false;
-    // If an update is in progress and a change arrives, we set this flag to ensure we run another update after completion to apply the latest state
+    // Tracks whether a roots change arrived while the previous refresh ran.
     pendingRootsUpdate = false;
     options;
     loggingState;
@@ -187,6 +188,7 @@ export class RootsManager {
         }
         finally {
             await this.recomputeAllowedDirectories();
+            Logger.info(`Roots updated: ${this.rootDirectories.length} root(s), ${this.allowedDirectoriesState.expanded.length} allowed dir(s)`);
             this.updatingRoots = false;
             // If a change arrived while we were running, apply it now.
             if (this.pendingRootsUpdate) {

package/dist/server/task-store.d.ts

@@ -0,0 +1,10 @@
+import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
+import type { Result } from '@modelcontextprotocol/sdk/types.js';
+export declare class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
+    private readonly cancelledResults;
+    getTaskResult(taskId: string, sessionId?: string): Promise<Result>;
+    storeTaskResult(taskId: string, status: 'completed' | 'failed', result: Result, sessionId?: string): Promise<void>;
+    updateTaskStatus(taskId: string, status: 'working' | 'input_required' | 'completed' | 'failed' | 'cancelled', statusMessage?: string, sessionId?: string): Promise<void>;
+    cleanup(): void;
+}
+export declare function createTaskStore(): ResultAwareInMemoryTaskStore;

package/dist/server/task-store.js

@@ -0,0 +1,73 @@
+import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
+import { ErrorCode } from '../lib/errors.js';
+const DEFAULT_CANCELLED_STATUS_MESSAGE = 'Client cancelled task execution.';
+function getTaskKey(taskId, sessionId) {
+    return `${sessionId ?? ''}:${taskId}`;
+}
+function buildCancelledTaskResult(statusMessage) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Error [${ErrorCode.CANCELLED}]: ${statusMessage ?? DEFAULT_CANCELLED_STATUS_MESSAGE}`,
+            },
+        ],
+        isError: true,
+        errorCode: ErrorCode.CANCELLED,
+    };
+}
+export class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
+    cancelledResults = new Map();
+    async getTaskResult(taskId, sessionId) {
+        try {
+            return await super.getTaskResult(taskId, sessionId);
+        }
+        catch (error) {
+            const task = await super.getTask(taskId, sessionId);
+            if (task?.status !== 'cancelled') {
+                throw error;
+            }
+            const key = getTaskKey(taskId, sessionId);
+            const existing = this.cancelledResults.get(key);
+            if (existing)
+                return existing;
+            const result = buildCancelledTaskResult(task.statusMessage);
+            this.cancelledResults.set(key, result);
+            return result;
+        }
+    }
+    async storeTaskResult(taskId, status, result, sessionId) {
+        try {
+            await super.storeTaskResult(taskId, status, result, sessionId);
+            if (status !== 'failed') {
+                this.cancelledResults.delete(getTaskKey(taskId, sessionId));
+            }
+        }
+        catch (error) {
+            const task = await super.getTask(taskId, sessionId);
+            if (task?.status !== 'cancelled') {
+                throw error;
+            }
+            this.cancelledResults.set(getTaskKey(taskId, sessionId), this.cancelledResults.get(getTaskKey(taskId, sessionId)) ?? result);
+        }
+    }
+    async updateTaskStatus(taskId, status, statusMessage, sessionId) {
+        await super.updateTaskStatus(taskId, status, statusMessage, sessionId);
+        const key = getTaskKey(taskId, sessionId);
+        if (status === 'cancelled') {
+            this.cancelledResults.set(key, this.cancelledResults.get(key) ??
+                buildCancelledTaskResult(statusMessage));
+            return;
+        }
+        if (status === 'completed' || status === 'failed') {
+            this.cancelledResults.delete(key);
+        }
+    }
+    cleanup() {
+        this.cancelledResults.clear();
+        super.cleanup();
+    }
+}
+export function createTaskStore() {
+    return new ResultAwareInMemoryTaskStore();
+}

package/dist/tools/apply-patch.js

@@ -1,12 +1,14 @@
-import * as path from 'node:path';
 import { readFile, stat } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
 import { applyPatch, parsePatch } from 'diff';
+import { withAbort } from '../lib/abort.js';
 import { MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY } from '../lib/constants.js';
-import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.js';
-import { atomicWriteFile, processInParallel, withAbort, } from '../lib/fs-helpers.js';
+import { ErrorCode, McpError } from '../lib/errors.js';
+import { atomicWriteFile, processInParallel } from '../lib/fs-helpers.js';
+import { Logger } from '../lib/logger.js';
 import { assertAllowedFileAccess, validateExistingPath } from '../lib/paths.js';
 import { ApplyPatchInputSchema, ApplyPatchOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
+import { buildStructuredError, buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
 export const APPLY_PATCH_TOOL = {
     name: 'apply_patch',
@@ -21,13 +23,12 @@ export const APPLY_PATCH_TOOL = {
     nuances: [
         'Multi-file patches use `path` as base directory; per-file results in `results[]`.',
     ],
-    gotchas: ['Patch must include valid hunk headers; use `dryRun=true` first.'],
     taskSupport: 'forbidden',
 };
 function assertPatchTargetSizeWithinLimit(filePath, size, maxFileSize) {
     if (size <= maxFileSize)
         return;
-    throw new McpError(ErrorCode.E_TOO_LARGE, `File too large for patch: ${filePath} (${size} bytes > ${maxFileSize} bytes).`, filePath, { size, maxFileSize });
+    throw new McpError(ErrorCode.TOO_LARGE, `File too large for patch (${size} bytes > ${maxFileSize} bytes).`, filePath, { size, maxFileSize });
 }
 function countStructuredPatchStats(diff) {
     let linesAdded = 0;
@@ -68,11 +69,15 @@ async function applyDiff(filePath, diff, options, signal) {
         return {
             path: validPath,
             applied: false,
-            error: 'Patch application failed',
+            error: buildStructuredError(new McpError(ErrorCode.INVALID_INPUT, 'Patch application failed', validPath), ErrorCode.INVALID_INPUT, validPath),
         };
     }
     if (patched === content) {
-        return { path: validPath, applied: false, error: 'Patch had no effect' };
+        return {
+            path: validPath,
+            applied: false,
+            error: buildStructuredError(new McpError(ErrorCode.INVALID_INPUT, 'Patch had no effect', validPath), ErrorCode.INVALID_INPUT, validPath),
+        };
     }
     const patchStats = countStructuredPatchStats(diff);
     if (!options.dryRun) {
@@ -88,10 +93,10 @@ async function processMultiFilePatch(basePath, parsed, options, signal) {
             return () => Promise.resolve({
                 path: '<unknown>',
                 applied: false,
-                error: 'Missing file name in patch header',
+                error: buildStructuredError(new McpError(ErrorCode.INVALID_INPUT, 'Missing file name in patch header'), ErrorCode.INVALID_INPUT),
             });
         }
-        const filePath = path.resolve(validBase, fileName);
+        const filePath = resolve(validBase, fileName);
         return async () => {
             try {
                 const result = await applyDiff(filePath, diff, options, signal);
@@ -101,7 +106,7 @@ async function processMultiFilePatch(basePath, parsed, options, signal) {
                 return {
                     path: fileName,
                     applied: false,
-                    error: formatUnknownErrorMessage(error),
+                    error: buildStructuredError(error, ErrorCode.INVALID_INPUT, filePath),
                 };
             }
         };
@@ -117,7 +122,17 @@ async function processMultiFilePatch(basePath, parsed, options, signal) {
         return acc;
     }, { applied: 0, hunks: 0, added: 0, removed: 0 });
     const label = options.dryRun ? ' (dry run)' : '';
+    if (totals.applied === 0) {
+        const failedPaths = results
+            .filter((r) => !r.applied)
+            .map((r) => r.path)
+            .join(', ');
+        throw new McpError(ErrorCode.INVALID_INPUT, `All ${parsed.length} patches failed${label}. Files: ${failedPaths}. Regenerate via diff_files.`);
+    }
     const text = `Applied ${totals.applied}/${parsed.length} file patches${label}`;
+    if (!options.dryRun) {
+        Logger.info(`apply_patch: ${basePath} (${totals.applied} file(s), +${totals.added}/-${totals.removed})`);
+    }
     return buildToolResponse(text, {
         ok: totals.applied === parsed.length,
         path: basePath,
@@ -130,13 +145,13 @@ async function processMultiFilePatch(basePath, parsed, options, signal) {
 }
 async function handleApplyPatch(args, signal) {
     if (!args.patch.trim()) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch content is empty.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Patch content is empty.');
     }
     const fuzzFactor = args.fuzzFactor ?? 0;
     const parsed = parsePatch(args.patch);
     const hasHunks = parsed.some((p) => p.hunks.length > 0);
     if (!hasHunks) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'Patch must include unified hunk headers (e.g., @@ -1,2 +1,2 @@).');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'Patch must include unified hunk headers (@@ -n,n +n,n @@).');
     }
     const options = {
         dryRun: args.dryRun,
@@ -148,17 +163,20 @@ async function handleApplyPatch(args, signal) {
     }
     const diff = parsed[0];
     if (!diff) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, 'No patch content found.');
+        throw new McpError(ErrorCode.INVALID_INPUT, 'No patch content found.');
     }
     const result = await applyDiff(args.path, diff, options, signal);
     if (!result.applied) {
-        throw new McpError(ErrorCode.E_INVALID_INPUT, result.error === 'Patch had no effect'
-            ? 'Patch had no effect \u2014 the file content is unchanged after applying. The patch may not match the current file content. Generate a fresh patch via diff_files and retry.'
-            : 'Patch application failed. The file content may have changed or patch context is insufficient. Generate a fresh patch via diff_files against the current file, then retry. If differences are minor, enable fuzzy matching with the fuzzFactor parameter.');
+        throw new McpError(ErrorCode.INVALID_INPUT, result.error?.message === 'Patch had no effect'
+            ? 'Patch had no effect. Content unchanged. Regenerate via diff_files.'
+            : 'Patch failed. Content may have changed. Regenerate via diff_files. For minor diffs, use fuzzFactor.');
     }
     const text = args.dryRun
         ? 'Dry run successful. Patch can be applied.'
         : `Successfully patched ${args.path}`;
+    if (!args.dryRun) {
+        Logger.info(`apply_patch: ${args.path} (+${result.linesAdded ?? 0}/-${result.linesRemoved ?? 0})`);
+    }
     return buildToolResponse(text, {
         ok: true,
         path: result.path,
@@ -172,19 +190,20 @@ export function registerApplyPatchTool(server, options = {}) {
     const handler = (args, extra) => executeToolWithDiagnostics({
         toolName: 'apply_patch',
         extra,
+        outputSchema: ApplyPatchOutputSchema,
         timedSignal: {},
         context: { path: args.path },
         run: (signal) => handleApplyPatch(args, signal),
-        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path),
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => {
-            const name = path.basename(args.path);
+            const name = basename(args.path);
             return args.dryRun ? `🛠 patch: ${name} [dry run]` : `🛠 patch: ${name}`;
         },
         completionMessage: (args, result) => {
-            const name = path.basename(args.path);
+            const name = basename(args.path);
             if (result.isError)
                 return `🛠 patch: ${name} • failed`;
             const sc = result.structuredContent;