@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/tools/delete-file.js

@@ -1,101 +1,344 @@
-import { lstat, rm, rmdir } from 'node:fs/promises';
+import { isInputRequiredResult } from '@modelcontextprotocol/server';
 import { basename } from 'node:path';
-import { withAbort } from '../lib/abort.js';
-import { ErrorCode, isNodeError, McpError } from '../lib/errors.js';
-import { Logger } from '../lib/logger.js';
-import { isAllowedDirectoryRoot, validatePathForWrite } from '../lib/paths.js';
-import { DeleteFileInputSchema, DeleteFileOutputSchema } from '../schemas.js';
-import { FILE_DELETE_ICONS } from './icons.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, } from './shared.js';
-import { registerStandardTool } from './task-support.js';
-export const DELETE_FILE_TOOL = {
-    name: 'rm',
-    title: 'Delete File',
-    description: 'Permanently delete a file or directory. This action is irreversible.',
-    inputSchema: DeleteFileInputSchema,
-    outputSchema: DeleteFileOutputSchema,
-    annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
-    icons: FILE_DELETE_ICONS,
-    gotchas: ['Non-empty directories require `recursive=true`.'],
-    taskSupport: 'forbidden',
-};
-async function handleDeleteFile(args, signal) {
-    const validPath = await validatePathForWrite(args.path, signal);
-    if (isAllowedDirectoryRoot(validPath)) {
-        throw new McpError(ErrorCode.ACCESS_DENIED, 'Deleting a workspace root directory is not allowed');
-    }
-    let stats;
+import * as z from 'zod/v4';
+import { processInParallel } from '../core/concurrency.js';
+import { ErrorCode, FsError, isFsError, isNodeError, isNotFoundErrno, Problem, } from '../core/errors.js';
+import { joinRoster, pathLabel } from '../core/fmt.js';
+import { getFileType } from '../core/fs.js';
+import { choiceInput, pendingRoundTrip, readAcceptedChoice } from '../core/input-required.js';
+import { defaultFalseBoolean, OperationSummarySchema, PerFileErrorSchema, RequiredPath, } from '../core/schema.js';
+import { PARALLEL_CONCURRENCY } from '../core/util.js';
+import { defineTool } from './define.js';
+const DeleteInputSchema = z.strictObject({
+    paths: z
+        .array(RequiredPath)
+        .min(1)
+        .max(1000)
+        .describe('Paths to delete (max 1000); accepts files, directories, or symlinks'),
+    recursive: defaultFalseBoolean('Delete directory contents recursively (required for non-empty directories)'),
+    ignoreIfNotExists: defaultFalseBoolean('Silently succeed if a path does not exist instead of returning an error'),
+});
+const DeletePerPathValueSchema = z.strictObject({
+    deleted: z.boolean().describe('True when the path was removed; false when the user chose Skip'),
+});
+const DeletePerPathSchema = z.strictObject({
+    path: z.string().describe('Requested path'),
+    value: DeletePerPathValueSchema.optional().describe('Delete outcome; present on success'),
+    error: PerFileErrorSchema.optional().describe('Error details; present on failure'),
+});
+// One envelope for every batch tool: `read` and `stat` already answer with
+// `{ results, summary }`, so `delete` does too. The old shape switched between
+// `{ ok, path }` and `{ ok: false, failures }` depending on the outcome, which
+// left a caller parsing two schemas for one tool and never named the paths in a
+// multi-delete's text.
+const DeleteOutputSchema = z.strictObject({
+    results: z
+        .array(DeletePerPathSchema)
+        .describe('Per-path results ordered to match the input paths'),
+    summary: OperationSummarySchema,
+});
+const ERR_NOT_EMPTY = new Error('Directory not empty. Set recursive: true.');
+function toDeleteFailure(path, error) {
+    // A missing path reached here as the raw errno text ("ENOENT: no such file or
+    // directory, lstat 'c:\...'"), while `stat` reported the same condition as
+    // "Path not found". One condition, one message — and the syscall name stays
+    // off the wire.
+    if (isNotFoundErrno(error)) {
+        return {
+            path,
+            error: Problem.toPerFileError(new FsError(ErrorCode.NOT_FOUND, 'Path not found', path), ErrorCode.NOT_FOUND, path),
+        };
+    }
+    if (isNodeError(error) &&
+        (error.code === 'ENOTEMPTY' || error.code === 'EISDIR' || error.code === 'EEXIST')) {
+        return {
+            path,
+            error: Problem.toPerFileError(ERR_NOT_EMPTY, ErrorCode.INVALID_INPUT, path),
+        };
+    }
+    return { path, error: Problem.toPerFileError(error, ErrorCode.UNKNOWN, path) };
+}
+/**
+ * Phase 1 (no mutation): validate, stat, and decide whether a path needs a
+ * confirmation before anything is deleted. A pending path is a recursive
+ * non-empty directory; everything else is ready to delete directly.
+ */
+async function planPath(inputPath, args, fs) {
+    let validPath;
     try {
-        stats = await withAbort(lstat(validPath), signal);
+        validPath = await fs.pathGuard.validatePathForDelete(inputPath);
     }
     catch (error) {
-        if (isNodeError(error) &&
-            error.code === 'ENOENT' &&
-            args.ignoreIfNotExists) {
-            return buildToolResponse(`Successfully deleted: ${args.path}`, {
-                ok: true,
-                path: validPath,
-            });
+        if (args.ignoreIfNotExists &&
+            ((isFsError(error) && error.code === ErrorCode.NOT_FOUND) || isNotFoundErrno(error))) {
+            return { status: 'noop', item: { path: inputPath } };
         }
-        throw error;
+        return { status: 'fail', failure: toDeleteFailure(inputPath, error) };
+    }
+    if (fs.pathGuard.isAllowedRoot(validPath)) {
+        return {
+            status: 'fail',
+            // Keyed by the REQUESTED path, like every other failure here: handleDelete
+            // orders results by input path, and a resolved key would not be found for
+            // a relative request.
+            failure: {
+                path: inputPath,
+                error: Problem.accessDenied('Deleting a workspace root directory is not allowed', {
+                    path: validPath,
+                }),
+            },
+        };
     }
-    if (stats.isDirectory() && !args.recursive) {
-        // Use rmdir for non-recursive directory deletes so non-empty directories
-        // consistently return ENOTEMPTY-style errors with actionable guidance.
-        await withAbort(rmdir(validPath), signal);
+    let firstStats;
+    try {
+        firstStats = await fs.lstat(validPath);
+    }
+    catch (error) {
+        if (isNotFoundErrno(error) && args.ignoreIfNotExists) {
+            return { status: 'noop', item: { path: inputPath } };
+        }
+        return { status: 'fail', failure: toDeleteFailure(inputPath, error) };
+    }
+    const itemType = getFileType(firstStats.stats);
+    let hasChildren = false;
+    if (args.recursive && itemType === 'directory') {
+        try {
+            hasChildren = await fs.hasChildrenUnchecked(validPath);
+        }
+        catch (error) {
+            return { status: 'fail', failure: toDeleteFailure(inputPath, error) };
+        }
+    }
+    const pending = hasChildren;
+    return { status: 'plan', plan: { inputPath, validPath, itemType, firstStats, pending } };
+}
+async function performDeletion(validPath, args, isDirectory, fsOps) {
+    if (isDirectory && !args.recursive) {
+        await fsOps.rmdir(validPath);
     }
     else {
-        await withAbort(rm(validPath, {
+        await fsOps.rm(validPath, {
             recursive: args.recursive,
             force: args.ignoreIfNotExists,
-        }), signal);
+        });
     }
-    Logger.info(`rm: ${args.path}`);
-    return buildToolResponse(`Successfully deleted: ${args.path}`, {
-        ok: true,
-        path: validPath,
-    });
 }
-export function registerDeleteFileTool(server, options = {}) {
-    const handler = (args, ctx) => executeToolWithDiagnostics({
-        toolName: 'rm',
-        ctx,
-        outputSchema: DeleteFileOutputSchema,
-        timedSignal: {},
-        context: { path: args.path },
-        run: async (signal) => {
-            const result = await handleDeleteFile(args, signal);
-            void ctx.log?.('info', `rm: ${args.path}`);
-            return result;
-        },
-        onError: (error) => {
-            if (isNodeError(error)) {
-                if (error.code === 'ENOENT') {
-                    return buildToolErrorResponse(error, ErrorCode.NOT_FOUND, args.path);
-                }
-                if (error.code === 'ENOTEMPTY') {
-                    return buildToolErrorResponse(new Error('Directory not empty. Set recursive: true.'), ErrorCode.INVALID_INPUT, args.path);
-                }
-                if (error.code === 'EISDIR') {
-                    return buildToolErrorResponse(new Error('Path is a directory. Set recursive: true.'), ErrorCode.INVALID_INPUT, args.path);
-                }
-                if (error.code === 'EEXIST') {
-                    return buildToolErrorResponse(new Error('Directory not empty. Set recursive: true.'), ErrorCode.INVALID_INPUT, args.path);
-                }
-                if (error.code === 'EPERM' || error.code === 'EACCES') {
-                    return buildToolErrorResponse(error, ErrorCode.PERMISSION_DENIED, args.path);
-                }
-            }
-            return buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path);
-        },
-    });
-    registerStandardTool(server, DELETE_FILE_TOOL, handler, options, {
-        progressMessage: (args) => `${DELETE_FILE_TOOL.title}: ${basename(args.path)}`,
-        completionMessage: (args, result) => {
-            const name = basename(args.path);
-            if (result.isError)
-                return `${DELETE_FILE_TOOL.title}: ${name} • ${result.errorCode}`;
-            return `${DELETE_FILE_TOOL.title}: ${name}`;
-        },
+/**
+ * Phase 2 (mutation): TOCTOU re-stat against the plan's first stat, then
+ * delete. A type or identity change across the confirmation gap fails closed
+ * rather than deleting a replacement object the user never confirmed.
+ */
+async function finalizeDeletion(plan, args, ctx) {
+    let currentStats;
+    try {
+        currentStats = await ctx.fs.lstat(plan.validPath);
+    }
+    catch (error) {
+        if (isNotFoundErrno(error) && args.ignoreIfNotExists) {
+            return { item: { path: plan.validPath } };
+        }
+        return { failure: toDeleteFailure(plan.inputPath, error) };
+    }
+    const currentItemType = getFileType(currentStats.stats);
+    // Identity comparison, not just the coarse category: a swap during the
+    // confirmation gap (delete original, create a same-named replacement) keeps
+    // the type but changes dev/ino/birthtimeMs. birthtimeMs is the primary
+    // cross-platform signal — dev/ino can read 0 on some non-POSIX drivers — so
+    // combine all three rather than trusting dev/ino alone.
+    const identityChanged = plan.firstStats.stats.dev !== currentStats.stats.dev ||
+        plan.firstStats.stats.ino !== currentStats.stats.ino ||
+        plan.firstStats.stats.birthtimeMs !== currentStats.stats.birthtimeMs;
+    if (plan.itemType !== 'other' && (currentItemType !== plan.itemType || identityChanged)) {
+        return {
+            failure: {
+                path: plan.validPath,
+                error: Problem.invalidInput(`Delete failed: item type changed from ${plan.itemType} to ${currentItemType} during confirmation.`, { path: plan.validPath }),
+            },
+        };
+    }
+    try {
+        await performDeletion(plan.validPath, args, currentStats.stats.isDirectory(), ctx.fs);
+    }
+    catch (error) {
+        return { failure: toDeleteFailure(plan.inputPath, error) };
+    }
+    ctx.log?.('info', `rm: ${plan.inputPath}`, 'delete');
+    return { item: { path: plan.validPath } };
+}
+/**
+ * Execute one planned path on the retry round. A pending path deletes only on
+ * an accepted `confirm: true`; decline, cancel, or a missing key report
+ * `CANCELLED` for that path (R3 proceed, R4/R5 cancelled). A non-pending path
+ * deletes directly (R14: non-pending items proceed alongside accepted ones).
+ */
+async function executePlan(plan, args, ctx, pendingSorted) {
+    if (plan.pending) {
+        const key = `confirm_${pendingSorted.indexOf(plan.validPath)}`;
+        const choice = readAcceptedChoice(ctx.inputResponses, key);
+        if (choice === 'skip') {
+            return { skipped: true, path: plan.validPath };
+        }
+        if (choice !== 'delete') {
+            return {
+                failure: {
+                    path: plan.validPath,
+                    error: Problem.cancelled('Delete cancelled: confirmation was declined or missing', {
+                        path: plan.validPath,
+                    }),
+                },
+            };
+        }
+    }
+    return finalizeDeletion(plan, args, ctx);
+}
+async function handleDelete(args, ctx) {
+    // Duplicate paths collapse: results are keyed by path, so a repeated entry
+    // would emit two rows for one deletion and inflate `summary.total`.
+    const paths = [...new Set(args.paths)];
+    // Phase 1 (no mutation): plan every path.
+    const planned = await processInParallel(paths, (inputPath) => planPath(inputPath, args, ctx.fs), PARALLEL_CONCURRENCY, ctx.signal);
+    const plans = [];
+    const earlyFailures = [];
+    const earlyNoop = [];
+    for (const { value: r } of planned.results) {
+        if (r.status === 'fail')
+            earlyFailures.push(r.failure);
+        else if (r.status === 'noop')
+            earlyNoop.push(r.item);
+        else
+            plans.push(r.plan);
+    }
+    for (const { index, error } of planned.errors) {
+        const path = paths[index] ?? '(unknown)';
+        earlyFailures.push({ path, error: { code: ErrorCode.UNKNOWN, message: error.message } });
+    }
+    // Pending set: recursive + non-empty directories, sorted and de-duplicated.
+    // `buildInputRequired` seals exactly this set into the requestState, and the
+    // retried round recomputes it from the same args so a swapped retry (accept
+    // for X, retry with Y) is rejected — the codec only proves the state was not
+    // tampered, not that it matches the current request (R9).
+    const pendingSorted = [...new Set(plans.filter((p) => p.pending).map((p) => p.validPath))].sort();
+    if (pendingSorted.length > 0) {
+        // Round 1 returns input_required (atomic — R14: nothing deleted yet, not
+        // even the non-pending items in the same call); a retry whose verified
+        // state does not bind this pending set throws (R9) via `pendingRoundTrip`.
+        const round = await pendingRoundTrip({
+            op: 'delete',
+            pending: pendingSorted,
+            requestState: ctx.requestState,
+            clientCapabilities: ctx.clientCapabilities,
+            buildInputs: (ps) => ps.map((p, i) => choiceInput(`confirm_${i}`, `Permanently delete "${p}" and all its contents? This cannot be undone.`, [
+                { value: 'delete', title: 'Delete' },
+                { value: 'skip', title: 'Skip' },
+            ])),
+        });
+        if (round !== undefined)
+            return round;
+    }
+    // Phase 2 (mutation): execute deletions for every planned path.
+    const executed = await processInParallel(plans, (plan) => executePlan(plan, args, ctx, pendingSorted), PARALLEL_CONCURRENCY, ctx.signal);
+    // Collect by path first, then emit in the caller's input order so
+    // `results[i]` lines up with `paths[i]` the way read/stat guarantee.
+    const byPath = new Map();
+    const record = (path, entry) => {
+        byPath.set(path, entry);
+    };
+    for (const n of earlyNoop)
+        record(n.path, { path: n.path, value: { deleted: true } });
+    for (const f of earlyFailures)
+        record(f.path, { path: f.path, error: f.error });
+    for (const { value: r } of executed.results) {
+        if ('skipped' in r) {
+            record(r.path, { path: r.path, value: { deleted: false } });
+        }
+        else if ('failure' in r) {
+            record(r.failure.path, { path: r.failure.path, error: r.failure.error });
+        }
+        else if (r.item.path) {
+            record(r.item.path, { path: r.item.path, value: { deleted: true } });
+        }
+    }
+    for (const { index, error } of executed.errors) {
+        const plan = plans[index];
+        const path = plan?.validPath ?? '(unknown)';
+        record(path, {
+            path,
+            error: { code: ErrorCode.UNKNOWN, message: error.message },
+        });
+    }
+    // A plan's `validPath` is the resolved absolute path, so a requested relative
+    // path will not find itself in the map by name — fall back through the plan.
+    const planByRequested = new Map(plans.map((p) => [p.inputPath, p.validPath]));
+    const results = paths.map((requested) => {
+        const resolved = planByRequested.get(requested);
+        const entry = byPath.get(requested) ?? (resolved !== undefined ? byPath.get(resolved) : undefined);
+        return (entry ?? {
+            path: requested,
+            error: { code: ErrorCode.UNKNOWN, message: 'Unknown delete failure' },
+        });
     });
+    const failed = results.filter((r) => r.error !== undefined).length;
+    return {
+        results,
+        summary: { total: results.length, succeeded: results.length - failed, failed },
+    };
 }
+export const DELETE_FILE = defineTool({
+    name: 'delete',
+    title: 'Delete File',
+    description: 'Permanently delete one or more files, directories, or symlinks (max 1000 per call). This action is irreversible. ' +
+        'Pass paths: [...] — there is no single-path form. ' +
+        'Non-empty directories require recursive=true and additionally prompt the user to confirm each one, ' +
+        'so the call returns without deleting anything until that confirmation comes back; ' +
+        'a client that cannot prompt gets an error naming the alternative. ' +
+        'Workspace root directories cannot be deleted.',
+    input: DeleteInputSchema,
+    output: DeleteOutputSchema,
+    // results[].value XOR results[].error, and `deleted: false` means the user
+    // chose Skip rather than a failure — not inferable from the description.
+    publishOutputSchema: true,
+    annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+    },
+    defaultErrorCode: ErrorCode.UNKNOWN,
+    progress: (args) => ({
+        label: 'Delete',
+        subject: args.paths.length === 1
+            ? basename(args.paths[0] ?? '')
+            : `${String(args.paths.length)} paths`,
+    }),
+    accessPaths: (args) => [...args.paths],
+    run: async (args, ctx) => {
+        const structured = await handleDelete(args, ctx);
+        // input_required is a return value, not a completed call: surface it
+        // verbatim so the executor short-circuits before building a CallToolResult.
+        if (isInputRequiredResult(structured))
+            return structured;
+        // Name every path and its outcome. The old text said "deleted 2 paths"
+        // without saying which two, so a partial failure was unreadable without
+        // parsing the structured half.
+        const { failed, total } = structured.summary;
+        // A lone failure carries its reason in the text. "delete: . FAILED (0/1 ok)"
+        // made the model re-read structuredContent to learn it was ACCESS_DENIED;
+        // with one path there is no ambiguity about which message applies.
+        if (total === 1 && failed === 1) {
+            const only = structured.results[0];
+            return {
+                structured,
+                text: `delete: ${only?.path ?? ''} FAILED — ${only?.error?.message ?? 'unknown error'}`,
+            };
+        }
+        const tokens = structured.results.map((r) => {
+            const label = pathLabel(r.path);
+            if (r.error)
+                return `${label} FAILED`;
+            return r.value?.deleted ? label : `${label} SKIPPED`;
+        });
+        const ratio = failed > 0 ? ` (${String(total - failed)}/${String(total)} ok)` : '';
+        return { structured, text: `delete: ${joinRoster(tokens)}${ratio}` };
+    },
+});
+//# sourceMappingURL=delete-file.js.map

package/dist/tools/delete-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-file.js","sourceRoot":"","sources":["../../src/tools/delete-file.ts"],"names":[],"mappings":"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","sourcesContent":["import type { InputRequiredResult } from '@modelcontextprotocol/server';\nimport { isInputRequiredResult } from '@modelcontextprotocol/server';\n\nimport { basename } from 'node:path';\n\nimport * as z from 'zod/v4';\n\nimport { processInParallel } from '../core/concurrency.js';\nimport {\n  ErrorCode,\n  FsError,\n  isFsError,\n  isNodeError,\n  isNotFoundErrno,\n  Problem,\n} from '../core/errors.js';\nimport { joinRoster, pathLabel } from '../core/fmt.js';\nimport type { FileType, GuardedFileSystem } from '../core/fs.js';\nimport { getFileType } from '../core/fs.js';\nimport { choiceInput, pendingRoundTrip, readAcceptedChoice } from '../core/input-required.js';\nimport {\n  defaultFalseBoolean,\n  OperationSummarySchema,\n  PerFileErrorSchema,\n  RequiredPath,\n} from '../core/schema.js';\nimport { PARALLEL_CONCURRENCY } from '../core/util.js';\nimport type { ToolCtx } from './define.js';\nimport { defineTool } from './define.js';\n\nconst DeleteInputSchema = z.strictObject({\n  paths: z\n    .array(RequiredPath)\n    .min(1)\n    .max(1000)\n    .describe('Paths to delete (max 1000); accepts files, directories, or symlinks'),\n  recursive: defaultFalseBoolean(\n    'Delete directory contents recursively (required for non-empty directories)',\n  ),\n  ignoreIfNotExists: defaultFalseBoolean(\n    'Silently succeed if a path does not exist instead of returning an error',\n  ),\n});\n\nconst DeletePerPathValueSchema = z.strictObject({\n  deleted: z.boolean().describe('True when the path was removed; false when the user chose Skip'),\n});\n\nconst DeletePerPathSchema = z.strictObject({\n  path: z.string().describe('Requested path'),\n  value: DeletePerPathValueSchema.optional().describe('Delete outcome; present on success'),\n  error: PerFileErrorSchema.optional().describe('Error details; present on failure'),\n});\n\n// One envelope for every batch tool: `read` and `stat` already answer with\n// `{ results, summary }`, so `delete` does too. The old shape switched between\n// `{ ok, path }` and `{ ok: false, failures }` depending on the outcome, which\n// left a caller parsing two schemas for one tool and never named the paths in a\n// multi-delete's text.\nconst DeleteOutputSchema = z.strictObject({\n  results: z\n    .array(DeletePerPathSchema)\n    .describe('Per-path results ordered to match the input paths'),\n  summary: OperationSummarySchema,\n});\n\ntype DeleteInput = z.infer<typeof DeleteInputSchema>;\ntype DeleteOutput = z.infer<typeof DeleteOutputSchema>;\ntype DeletePerPathResult = z.infer<typeof DeletePerPathSchema>;\n\n// Internal types for error handling\ninterface DeletedItem {\n  path: string;\n}\ninterface DeleteFailure {\n  path: string;\n  error: {\n    code: string;\n    message: string;\n    path?: string;\n    suggestion?: string;\n  };\n}\n\nconst ERR_NOT_EMPTY = new Error('Directory not empty. Set recursive: true.');\n\nfunction toDeleteFailure(path: string, error: unknown): DeleteFailure {\n  // A missing path reached here as the raw errno text (\"ENOENT: no such file or\n  // directory, lstat 'c:\\...'\"), while `stat` reported the same condition as\n  // \"Path not found\". One condition, one message — and the syscall name stays\n  // off the wire.\n  if (isNotFoundErrno(error)) {\n    return {\n      path,\n      error: Problem.toPerFileError(\n        new FsError(ErrorCode.NOT_FOUND, 'Path not found', path),\n        ErrorCode.NOT_FOUND,\n        path,\n      ),\n    };\n  }\n  if (\n    isNodeError(error) &&\n    (error.code === 'ENOTEMPTY' || error.code === 'EISDIR' || error.code === 'EEXIST')\n  ) {\n    return {\n      path,\n      error: Problem.toPerFileError(ERR_NOT_EMPTY, ErrorCode.INVALID_INPUT, path),\n    };\n  }\n  return { path, error: Problem.toPerFileError(error, ErrorCode.UNKNOWN, path) };\n}\n\ntype LstatResult = Awaited<ReturnType<GuardedFileSystem['lstat']>>;\ntype ItemType = FileType;\n\n/** A path's pre-checked plan: validated, statted, and flagged if it needs confirmation. */\ninterface DeletePlan {\n  inputPath: string;\n  validPath: string;\n  itemType: ItemType;\n  firstStats: LstatResult;\n  /** Recursive + non-empty directory: needs a round-trip confirmation. */\n  pending: boolean;\n}\n\ntype PlanResult =\n  | { status: 'fail'; failure: DeleteFailure }\n  | { status: 'noop'; item: DeletedItem }\n  | { status: 'plan'; plan: DeletePlan };\n\n/**\n * Phase 1 (no mutation): validate, stat, and decide whether a path needs a\n * confirmation before anything is deleted. A pending path is a recursive\n * non-empty directory; everything else is ready to delete directly.\n */\nasync function planPath(\n  inputPath: string,\n  args: Pick<DeleteInput, 'recursive' | 'ignoreIfNotExists'>,\n  fs: Pick<GuardedFileSystem, 'pathGuard' | 'lstat' | 'hasChildrenUnchecked'>,\n): Promise<PlanResult> {\n  let validPath: string;\n  try {\n    validPath = await fs.pathGuard.validatePathForDelete(inputPath);\n  } catch (error) {\n    if (\n      args.ignoreIfNotExists &&\n      ((isFsError(error) && error.code === ErrorCode.NOT_FOUND) || isNotFoundErrno(error))\n    ) {\n      return { status: 'noop', item: { path: inputPath } };\n    }\n    return { status: 'fail', failure: toDeleteFailure(inputPath, error) };\n  }\n\n  if (fs.pathGuard.isAllowedRoot(validPath)) {\n    return {\n      status: 'fail',\n      // Keyed by the REQUESTED path, like every other failure here: handleDelete\n      // orders results by input path, and a resolved key would not be found for\n      // a relative request.\n      failure: {\n        path: inputPath,\n        error: Problem.accessDenied('Deleting a workspace root directory is not allowed', {\n          path: validPath,\n        }),\n      },\n    };\n  }\n\n  let firstStats: LstatResult;\n  try {\n    firstStats = await fs.lstat(validPath);\n  } catch (error) {\n    if (isNotFoundErrno(error) && args.ignoreIfNotExists) {\n      return { status: 'noop', item: { path: inputPath } };\n    }\n    return { status: 'fail', failure: toDeleteFailure(inputPath, error) };\n  }\n\n  const itemType = getFileType(firstStats.stats);\n  let hasChildren = false;\n  if (args.recursive && itemType === 'directory') {\n    try {\n      hasChildren = await fs.hasChildrenUnchecked(validPath);\n    } catch (error) {\n      return { status: 'fail', failure: toDeleteFailure(inputPath, error) };\n    }\n  }\n  const pending = hasChildren;\n  return { status: 'plan', plan: { inputPath, validPath, itemType, firstStats, pending } };\n}\n\nasync function performDeletion(\n  validPath: string,\n  args: Pick<DeleteInput, 'recursive' | 'ignoreIfNotExists'>,\n  isDirectory: boolean,\n  fsOps: Pick<GuardedFileSystem, 'rm' | 'rmdir'>,\n): Promise<void> {\n  if (isDirectory && !args.recursive) {\n    await fsOps.rmdir(validPath);\n  } else {\n    await fsOps.rm(validPath, {\n      recursive: args.recursive,\n      force: args.ignoreIfNotExists,\n    });\n  }\n}\n\n/**\n * Phase 2 (mutation): TOCTOU re-stat against the plan's first stat, then\n * delete. A type or identity change across the confirmation gap fails closed\n * rather than deleting a replacement object the user never confirmed.\n */\nasync function finalizeDeletion(\n  plan: DeletePlan,\n  args: Pick<DeleteInput, 'recursive' | 'ignoreIfNotExists'>,\n  ctx: Pick<ToolCtx, 'fs' | 'log'>,\n): Promise<{ item: DeletedItem } | { failure: DeleteFailure }> {\n  let currentStats: LstatResult;\n  try {\n    currentStats = await ctx.fs.lstat(plan.validPath);\n  } catch (error) {\n    if (isNotFoundErrno(error) && args.ignoreIfNotExists) {\n      return { item: { path: plan.validPath } };\n    }\n    return { failure: toDeleteFailure(plan.inputPath, error) };\n  }\n\n  const currentItemType = getFileType(currentStats.stats);\n  // Identity comparison, not just the coarse category: a swap during the\n  // confirmation gap (delete original, create a same-named replacement) keeps\n  // the type but changes dev/ino/birthtimeMs. birthtimeMs is the primary\n  // cross-platform signal — dev/ino can read 0 on some non-POSIX drivers — so\n  // combine all three rather than trusting dev/ino alone.\n  const identityChanged =\n    plan.firstStats.stats.dev !== currentStats.stats.dev ||\n    plan.firstStats.stats.ino !== currentStats.stats.ino ||\n    plan.firstStats.stats.birthtimeMs !== currentStats.stats.birthtimeMs;\n  if (plan.itemType !== 'other' && (currentItemType !== plan.itemType || identityChanged)) {\n    return {\n      failure: {\n        path: plan.validPath,\n        error: Problem.invalidInput(\n          `Delete failed: item type changed from ${plan.itemType} to ${currentItemType} during confirmation.`,\n          { path: plan.validPath },\n        ),\n      },\n    };\n  }\n\n  try {\n    await performDeletion(plan.validPath, args, currentStats.stats.isDirectory(), ctx.fs);\n  } catch (error) {\n    return { failure: toDeleteFailure(plan.inputPath, error) };\n  }\n\n  ctx.log?.('info', `rm: ${plan.inputPath}`, 'delete');\n  return { item: { path: plan.validPath } };\n}\n\n/**\n * Execute one planned path on the retry round. A pending path deletes only on\n * an accepted `confirm: true`; decline, cancel, or a missing key report\n * `CANCELLED` for that path (R3 proceed, R4/R5 cancelled). A non-pending path\n * deletes directly (R14: non-pending items proceed alongside accepted ones).\n */\nasync function executePlan(\n  plan: DeletePlan,\n  args: Pick<DeleteInput, 'recursive' | 'ignoreIfNotExists'>,\n  ctx: Pick<ToolCtx, 'fs' | 'inputResponses' | 'log'>,\n  pendingSorted: readonly string[],\n): Promise<{ item: DeletedItem } | { failure: DeleteFailure } | { skipped: true; path: string }> {\n  if (plan.pending) {\n    const key = `confirm_${pendingSorted.indexOf(plan.validPath)}`;\n    const choice = readAcceptedChoice(ctx.inputResponses, key);\n    if (choice === 'skip') {\n      return { skipped: true as const, path: plan.validPath };\n    }\n    if (choice !== 'delete') {\n      return {\n        failure: {\n          path: plan.validPath,\n          error: Problem.cancelled('Delete cancelled: confirmation was declined or missing', {\n            path: plan.validPath,\n          }),\n        },\n      };\n    }\n  }\n  return finalizeDeletion(plan, args, ctx);\n}\n\nasync function handleDelete(\n  args: DeleteInput,\n  ctx: ToolCtx,\n): Promise<DeleteOutput | InputRequiredResult> {\n  // Duplicate paths collapse: results are keyed by path, so a repeated entry\n  // would emit two rows for one deletion and inflate `summary.total`.\n  const paths = [...new Set(args.paths)];\n\n  // Phase 1 (no mutation): plan every path.\n  const planned = await processInParallel(\n    paths,\n    (inputPath) => planPath(inputPath, args, ctx.fs),\n    PARALLEL_CONCURRENCY,\n    ctx.signal,\n  );\n\n  const plans: DeletePlan[] = [];\n  const earlyFailures: DeleteFailure[] = [];\n  const earlyNoop: DeletedItem[] = [];\n  for (const { value: r } of planned.results) {\n    if (r.status === 'fail') earlyFailures.push(r.failure);\n    else if (r.status === 'noop') earlyNoop.push(r.item);\n    else plans.push(r.plan);\n  }\n  for (const { index, error } of planned.errors) {\n    const path = paths[index] ?? '(unknown)';\n    earlyFailures.push({ path, error: { code: ErrorCode.UNKNOWN, message: error.message } });\n  }\n\n  // Pending set: recursive + non-empty directories, sorted and de-duplicated.\n  // `buildInputRequired` seals exactly this set into the requestState, and the\n  // retried round recomputes it from the same args so a swapped retry (accept\n  // for X, retry with Y) is rejected — the codec only proves the state was not\n  // tampered, not that it matches the current request (R9).\n  const pendingSorted = [...new Set(plans.filter((p) => p.pending).map((p) => p.validPath))].sort();\n\n  if (pendingSorted.length > 0) {\n    // Round 1 returns input_required (atomic — R14: nothing deleted yet, not\n    // even the non-pending items in the same call); a retry whose verified\n    // state does not bind this pending set throws (R9) via `pendingRoundTrip`.\n    const round = await pendingRoundTrip({\n      op: 'delete',\n      pending: pendingSorted,\n      requestState: ctx.requestState,\n      clientCapabilities: ctx.clientCapabilities,\n      buildInputs: (ps) =>\n        ps.map((p, i) =>\n          choiceInput(\n            `confirm_${i}`,\n            `Permanently delete \"${p}\" and all its contents? This cannot be undone.`,\n            [\n              { value: 'delete', title: 'Delete' },\n              { value: 'skip', title: 'Skip' },\n            ],\n          ),\n        ),\n    });\n    if (round !== undefined) return round;\n  }\n\n  // Phase 2 (mutation): execute deletions for every planned path.\n  const executed = await processInParallel(\n    plans,\n    (plan) => executePlan(plan, args, ctx, pendingSorted),\n    PARALLEL_CONCURRENCY,\n    ctx.signal,\n  );\n\n  // Collect by path first, then emit in the caller's input order so\n  // `results[i]` lines up with `paths[i]` the way read/stat guarantee.\n  const byPath = new Map<string, DeletePerPathResult>();\n  const record = (path: string, entry: DeletePerPathResult): void => {\n    byPath.set(path, entry);\n  };\n  for (const n of earlyNoop) record(n.path, { path: n.path, value: { deleted: true } });\n  for (const f of earlyFailures) record(f.path, { path: f.path, error: f.error });\n  for (const { value: r } of executed.results) {\n    if ('skipped' in r) {\n      record(r.path, { path: r.path, value: { deleted: false } });\n    } else if ('failure' in r) {\n      record(r.failure.path, { path: r.failure.path, error: r.failure.error });\n    } else if (r.item.path) {\n      record(r.item.path, { path: r.item.path, value: { deleted: true } });\n    }\n  }\n  for (const { index, error } of executed.errors) {\n    const plan = plans[index];\n    const path = plan?.validPath ?? '(unknown)';\n    record(path, {\n      path,\n      error: { code: ErrorCode.UNKNOWN, message: error.message },\n    });\n  }\n\n  // A plan's `validPath` is the resolved absolute path, so a requested relative\n  // path will not find itself in the map by name — fall back through the plan.\n  const planByRequested = new Map(plans.map((p) => [p.inputPath, p.validPath]));\n  const results: DeletePerPathResult[] = paths.map((requested) => {\n    const resolved = planByRequested.get(requested);\n    const entry =\n      byPath.get(requested) ?? (resolved !== undefined ? byPath.get(resolved) : undefined);\n    return (\n      entry ?? {\n        path: requested,\n        error: { code: ErrorCode.UNKNOWN, message: 'Unknown delete failure' },\n      }\n    );\n  });\n\n  const failed = results.filter((r) => r.error !== undefined).length;\n  return {\n    results,\n    summary: { total: results.length, succeeded: results.length - failed, failed },\n  };\n}\n\nexport const DELETE_FILE = defineTool({\n  name: 'delete',\n  title: 'Delete File',\n  description:\n    'Permanently delete one or more files, directories, or symlinks (max 1000 per call). This action is irreversible. ' +\n    'Pass paths: [...] — there is no single-path form. ' +\n    'Non-empty directories require recursive=true and additionally prompt the user to confirm each one, ' +\n    'so the call returns without deleting anything until that confirmation comes back; ' +\n    'a client that cannot prompt gets an error naming the alternative. ' +\n    'Workspace root directories cannot be deleted.',\n  input: DeleteInputSchema,\n  output: DeleteOutputSchema,\n  // results[].value XOR results[].error, and `deleted: false` means the user\n  // chose Skip rather than a failure — not inferable from the description.\n  publishOutputSchema: true,\n  annotations: {\n    readOnlyHint: false,\n    idempotentHint: false,\n    destructiveHint: true,\n    openWorldHint: false,\n  },\n  defaultErrorCode: ErrorCode.UNKNOWN,\n  progress: (args) => ({\n    label: 'Delete',\n    subject:\n      args.paths.length === 1\n        ? basename(args.paths[0] ?? '')\n        : `${String(args.paths.length)} paths`,\n  }),\n  accessPaths: (args) => [...args.paths],\n  run: async (args, ctx) => {\n    const structured = await handleDelete(args, ctx);\n    // input_required is a return value, not a completed call: surface it\n    // verbatim so the executor short-circuits before building a CallToolResult.\n    if (isInputRequiredResult(structured)) return structured;\n    // Name every path and its outcome. The old text said \"deleted 2 paths\"\n    // without saying which two, so a partial failure was unreadable without\n    // parsing the structured half.\n    const { failed, total } = structured.summary;\n    // A lone failure carries its reason in the text. \"delete: . FAILED (0/1 ok)\"\n    // made the model re-read structuredContent to learn it was ACCESS_DENIED;\n    // with one path there is no ambiguity about which message applies.\n    if (total === 1 && failed === 1) {\n      const only = structured.results[0];\n      return {\n        structured,\n        text: `delete: ${only?.path ?? ''} FAILED — ${only?.error?.message ?? 'unknown error'}`,\n      };\n    }\n    const tokens = structured.results.map((r) => {\n      const label = pathLabel(r.path);\n      if (r.error) return `${label} FAILED`;\n      return r.value?.deleted ? label : `${label} SKIPPED`;\n    });\n    const ratio = failed > 0 ? ` (${String(total - failed)}/${String(total)} ok)` : '';\n    return { structured, text: `delete: ${joinRoster(tokens)}${ratio}` };\n  },\n});\n"]}

package/dist/tools/diff.d.ts

@@ -0,0 +1,2 @@
+export declare const DIFF: import("./define.js").DefinedTool;
+//# sourceMappingURL=diff.d.ts.map

package/dist/tools/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/tools/diff.ts"],"names":[],"mappings":"AAqGA,eAAO,MAAM,IAAI,mCAoBf,CAAC"}

package/dist/tools/diff.js

@@ -0,0 +1,94 @@
+import { basename } from 'node:path';
+import * as z from 'zod/v4';
+import { createTwoFilesPatch, diffLines } from 'diff';
+import { NonNegInt, PositiveInt, RequiredPath } from '../core/schema.js';
+import { putJsonResource } from '../core/store.js';
+import { defineTool } from './define.js';
+const DiffInputSchema = z.strictObject({
+    a: RequiredPath.describe('First file to compare'),
+    b: RequiredPath.describe('Second file to compare'),
+    context: PositiveInt.max(50)
+        .default(3)
+        .describe('Number of context lines surrounding each change (default: 3)'),
+});
+const DiffOutputSchema = z.strictObject({
+    a: z.string().describe('Resolved absolute path of the first file'),
+    b: z.string().describe('Resolved absolute path of the second file'),
+    // The unified diff itself rides the text content block; `resourceUri` holds
+    // the full copy for a client that wants to fetch it separately.
+    linesAdded: NonNegInt.describe('Number of lines added'),
+    linesRemoved: NonNegInt.describe('Number of lines removed'),
+    resourceUri: z
+        .string()
+        .optional()
+        .describe('URI to the full diff in the resource store (present when resource store is enabled)'),
+});
+async function handleDiff(args, ctx) {
+    const [{ validPath: validA, content: contentA }, { validPath: validB, content: contentB }] = await Promise.all([
+        ctx.fs.readEditableText(args.a, { signal: ctx.signal, tool: 'diff' }),
+        ctx.fs.readEditableText(args.b, { signal: ctx.signal, tool: 'diff' }),
+    ]);
+    // createTwoFilesPatch returns the unified diff string synchronously on diff v9
+    // (the { callback } option does not fire on this version — verified).
+    const diffText = createTwoFilesPatch(basename(validA), basename(validB), contentA, contentB, 'a', 'b', { context: args.context });
+    // diffLines returns the change list synchronously; count added/removed lines.
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    for (const part of diffLines(contentA, contentB)) {
+        if (part.added)
+            linesAdded += part.count;
+        else if (part.removed)
+            linesRemoved += part.count;
+    }
+    let resourceUri;
+    let link;
+    // Identical files: the diff has no hunks, so externalizing it buys the client
+    // a link to nothing and burns a store slot the next real diff wants.
+    if (ctx.resourceStore && linesAdded + linesRemoved > 0) {
+        const result = putJsonResource(ctx.resourceStore, 'diff', {
+            diff: diffText,
+            linesAdded,
+            linesRemoved,
+            a: validA,
+            b: validB,
+        });
+        resourceUri = result.entry.uri;
+        link = result.link;
+    }
+    // The diff shipped three times: this text block, `structured.diff`, and the
+    // externalized store entry. The text block is the one a model reads, so the
+    // structured copy goes — `resourceUri` still holds the full diff for a client
+    // that wants to fetch it separately.
+    return {
+        structured: {
+            a: validA,
+            b: validB,
+            linesAdded,
+            linesRemoved,
+            ...(resourceUri !== undefined ? { resourceUri } : {}),
+        },
+        text: diffText,
+        ...(link !== undefined ? { resources: [link] } : {}),
+    };
+}
+export const DIFF = defineTool({
+    name: 'diff',
+    title: 'Diff',
+    description: 'Compare two files and return a unified diff with line counts. Pass the two paths as a and b. ' +
+        'Use after an edit dry-run to compare against another file, or to inspect changes between two paths.',
+    input: DiffInputSchema,
+    output: DiffOutputSchema,
+    annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
+    progress: (args) => ({
+        label: 'Diff',
+        subject: basename(args.a),
+    }),
+    accessPaths: (args) => [args.a, args.b],
+    run: (args, ctx) => handleDiff(args, ctx),
+});
+//# sourceMappingURL=diff.js.map

package/dist/tools/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../src/tools/diff.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ContentBlock } from '@modelcontextprotocol/server';\n\nimport { basename } from 'node:path';\n\nimport * as z from 'zod/v4';\nimport { createTwoFilesPatch, diffLines } from 'diff';\n\nimport { NonNegInt, PositiveInt, RequiredPath } from '../core/schema.js';\nimport { putJsonResource } from '../core/store.js';\nimport { defineTool, type ToolCtx } from './define.js';\n\nconst DiffInputSchema = z.strictObject({\n  a: RequiredPath.describe('First file to compare'),\n  b: RequiredPath.describe('Second file to compare'),\n  context: PositiveInt.max(50)\n    .default(3)\n    .describe('Number of context lines surrounding each change (default: 3)'),\n});\n\nconst DiffOutputSchema = z.strictObject({\n  a: z.string().describe('Resolved absolute path of the first file'),\n  b: z.string().describe('Resolved absolute path of the second file'),\n  // The unified diff itself rides the text content block; `resourceUri` holds\n  // the full copy for a client that wants to fetch it separately.\n  linesAdded: NonNegInt.describe('Number of lines added'),\n  linesRemoved: NonNegInt.describe('Number of lines removed'),\n  resourceUri: z\n    .string()\n    .optional()\n    .describe(\n      'URI to the full diff in the resource store (present when resource store is enabled)',\n    ),\n});\n\nasync function handleDiff(\n  args: z.infer<typeof DiffInputSchema>,\n  ctx: ToolCtx,\n): Promise<{\n  structured: z.infer<typeof DiffOutputSchema>;\n  text: string;\n  resources?: ContentBlock[];\n}> {\n  const [{ validPath: validA, content: contentA }, { validPath: validB, content: contentB }] =\n    await Promise.all([\n      ctx.fs.readEditableText(args.a, { signal: ctx.signal, tool: 'diff' }),\n      ctx.fs.readEditableText(args.b, { signal: ctx.signal, tool: 'diff' }),\n    ]);\n\n  // createTwoFilesPatch returns the unified diff string synchronously on diff v9\n  // (the { callback } option does not fire on this version — verified).\n  const diffText = createTwoFilesPatch(\n    basename(validA),\n    basename(validB),\n    contentA,\n    contentB,\n    'a',\n    'b',\n    { context: args.context },\n  );\n\n  // diffLines returns the change list synchronously; count added/removed lines.\n  let linesAdded = 0;\n  let linesRemoved = 0;\n  for (const part of diffLines(contentA, contentB)) {\n    if (part.added) linesAdded += part.count;\n    else if (part.removed) linesRemoved += part.count;\n  }\n\n  let resourceUri: string | undefined;\n  let link: ReturnType<typeof putJsonResource>['link'] | undefined;\n  // Identical files: the diff has no hunks, so externalizing it buys the client\n  // a link to nothing and burns a store slot the next real diff wants.\n  if (ctx.resourceStore && linesAdded + linesRemoved > 0) {\n    const result = putJsonResource(ctx.resourceStore, 'diff', {\n      diff: diffText,\n      linesAdded,\n      linesRemoved,\n      a: validA,\n      b: validB,\n    });\n    resourceUri = result.entry.uri;\n    link = result.link;\n  }\n\n  // The diff shipped three times: this text block, `structured.diff`, and the\n  // externalized store entry. The text block is the one a model reads, so the\n  // structured copy goes — `resourceUri` still holds the full diff for a client\n  // that wants to fetch it separately.\n  return {\n    structured: {\n      a: validA,\n      b: validB,\n      linesAdded,\n      linesRemoved,\n      ...(resourceUri !== undefined ? { resourceUri } : {}),\n    },\n    text: diffText,\n    ...(link !== undefined ? { resources: [link] } : {}),\n  };\n}\n\nexport const DIFF = defineTool({\n  name: 'diff',\n  title: 'Diff',\n  description:\n    'Compare two files and return a unified diff with line counts. Pass the two paths as a and b. ' +\n    'Use after an edit dry-run to compare against another file, or to inspect changes between two paths.',\n  input: DiffInputSchema,\n  output: DiffOutputSchema,\n  annotations: {\n    readOnlyHint: true,\n    idempotentHint: true,\n    destructiveHint: false,\n    openWorldHint: false,\n  },\n  progress: (args) => ({\n    label: 'Diff',\n    subject: basename(args.a),\n  }),\n  accessPaths: (args) => [args.a, args.b],\n  run: (args, ctx) => handleDiff(args, ctx),\n});\n"]}

package/dist/tools/edit.d.ts

@@ -0,0 +1,2 @@
+export declare const EDIT: import("./define.js").DefinedTool;
+//# sourceMappingURL=edit.d.ts.map

package/dist/tools/edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../src/tools/edit.ts"],"names":[],"mappings":"AAogBA,eAAO,MAAM,IAAI,mCAyEf,CAAC"}