@j0hanz/filesystem-mcp 1.13.1 → 1.14.0

package/dist/schemas.js

@@ -1,26 +1,20 @@
 import { z } from 'zod';
 import { DEFAULT_LIST_MAX_ENTRIES, DEFAULT_SEARCH_CONTENT_RESULTS, DEFAULT_SEARCH_RESULTS, DEFAULT_TREE_DEPTH, DEFAULT_TREE_ENTRIES, MAX_LIST_ENTRIES, MAX_SEARCH_DEPTH, MAX_SEARCH_RESULTS, MAX_TREE_DEPTH, MAX_TREE_ENTRIES, } from './lib/constants.js';
 import { ErrorCode } from './lib/errors.js';
-function isSafeGlobPattern(value) {
-    if (value.length === 0)
-        return false;
-    if (value.includes('**/**/**'))
-        return false;
-    const absolutePattern = /^([/\\]|[A-Za-z]:[/\\]|\\\\)/u;
-    if (absolutePattern.test(value)) {
-        return false;
-    }
-    if (/[\\/]\.\.(?:[/\\]|$)/u.test(value) || value.startsWith('..')) {
-        return false;
-    }
-    return true;
-}
+import { isSafeGlobPattern } from './lib/globs.js';
 const MAX_PATH_LENGTH = 4096;
 const DESC_PATH_ROOT = 'Base directory (default: root). Absolute path required if multiple roots.';
 const DESC_PATH_REQUIRED = 'Absolute path to file or directory.';
 function defaultFalseBoolean(description) {
     return z.boolean().optional().default(false).describe(description);
 }
+const SuccessFlagSchema = z.literal(true);
+const NonNegativeIntegerSchema = z.int().min(0, 'Min: 0');
+const PositiveIntegerSchema = z.int().min(1, 'Min: 1');
+const IsoDateTimeSchema = z.iso.datetime();
+const Sha256HexSchema = z
+    .string()
+    .regex(/^[a-f0-9]{64}$/u, 'Expected SHA-256 hex digest');
 const PathSchemaBase = z
     .string()
     .max(MAX_PATH_LENGTH, `Path too long (max ${MAX_PATH_LENGTH} chars)`);
@@ -48,10 +42,6 @@ const ErrorSchema = z.strictObject({
     path: z.string().optional().describe('Relevant path'),
     suggestion: z.string().optional().describe('Fix suggestion'),
 });
-export const ToolErrorResponseSchema = z.strictObject({
-    ok: z.literal(false).describe('Operation failed'),
-    error: ErrorSchema.describe('Error details'),
-});
 const HeadLinesSchema = z
     .int({ error: 'Must be integer' })
     .min(1, 'Min: 1')
@@ -65,11 +55,12 @@ const TailLinesSchema = z
     .optional()
     .describe('Read last N lines');
 const LineNumberSchema = z.int({ error: 'Must be integer' }).min(1, 'Min: 1');
-function addReadRangeIssue(ctx, path, message) {
+function addReadRangeIssue(ctx, input, path, message) {
     ctx.addIssue({
         code: 'custom',
         path: [path],
         message,
+        input,
     });
 }
 const validateReadRange = (value, ctx) => {
@@ -78,18 +69,14 @@ const validateReadRange = (value, ctx) => {
     const hasStart = value.startLine !== undefined;
     const hasEnd = value.endLine !== undefined;
     if (hasHead && (hasStart || hasEnd)) {
-        addReadRangeIssue(ctx, 'head', "Cannot use 'head' with 'startLine'/'endLine'");
+        addReadRangeIssue(ctx, value, 'head', "Cannot use 'head' with 'startLine'/'endLine'");
     }
     if (hasTail && (hasHead || hasStart || hasEnd)) {
-        addReadRangeIssue(ctx, 'tail', "Cannot use 'tail' with 'head'/'startLine'/'endLine'");
+        addReadRangeIssue(ctx, value, 'tail', "Cannot use 'tail' with 'head'/'startLine'/'endLine'");
     }
-    if (hasEnd && !hasStart) {
-        addReadRangeIssue(ctx, 'endLine', "'endLine' requires 'startLine'");
-    }
-    if (value.startLine !== undefined &&
-        value.endLine !== undefined &&
-        value.endLine < value.startLine) {
-        addReadRangeIssue(ctx, 'endLine', "'endLine' must be >= 'startLine'");
+    const effectiveStart = value.startLine ?? 1;
+    if (value.endLine !== undefined && value.endLine < effectiveStart) {
+        addReadRangeIssue(ctx, value, 'endLine', "'endLine' must be >= 'startLine'");
     }
 };
 function createReadRangeInputFields(descriptions) {
@@ -104,20 +91,20 @@ const FileInfoSchema = z.strictObject({
     name: z.string().describe('Name'),
     path: z.string().describe('Absolute path'),
     type: FileTypeSchema.describe('Type'),
-    size: z.number().describe('Size (bytes)'),
-    tokenEstimate: z.number().optional().describe('Est. tokens (size/4)'),
-    created: z.string().describe('Created'),
-    modified: z.string().describe('Modified'),
-    accessed: z.string().describe('Accessed'),
+    size: NonNegativeIntegerSchema.describe('Size (bytes)'),
+    tokenEstimate: NonNegativeIntegerSchema.optional().describe('Est. tokens (size/4)'),
+    created: IsoDateTimeSchema.describe('Created'),
+    modified: IsoDateTimeSchema.describe('Modified'),
+    accessed: IsoDateTimeSchema.describe('Accessed'),
     permissions: z.string().describe('Permissions'),
     isHidden: z.boolean().describe('Hidden?'),
     mimeType: z.string().optional().describe('MIME type'),
     symlinkTarget: z.string().optional().describe('Target (symlink)'),
 });
 const OperationSummarySchema = z.strictObject({
-    total: z.number().describe('Total'),
-    succeeded: z.number().describe('Succeeded'),
-    failed: z.number().describe('Failed'),
+    total: NonNegativeIntegerSchema.describe('Total'),
+    succeeded: NonNegativeIntegerSchema.describe('Succeeded'),
+    failed: NonNegativeIntegerSchema.describe('Failed'),
 });
 export const ListDirectoryInputSchema = z.strictObject({
     path: OptionalPathSchema.describe(DESC_PATH_ROOT),
@@ -143,6 +130,9 @@ export const ListDirectoryInputSchema = z.strictObject({
         .string()
         .min(1, 'Pattern required')
         .max(1000, 'Max 1000 chars')
+        .refine((val) => isSafeGlobPattern(val), {
+        error: 'Invalid glob or unsafe path (absolute/.. forbidden)',
+    })
         .optional()
         .describe('Optional glob pattern filter (e.g. "**/*.ts")'),
     includeSymlinkTargets: defaultFalseBoolean('Resolve and include symlink targets in results'),
@@ -240,7 +230,6 @@ export const SearchContentInputSchema = z.strictObject({
         .describe('Glob for candidate files (e.g. "**/*.ts")'),
     includeHidden: defaultFalseBoolean('Include hidden items (starting with .)'),
     includeIgnored: defaultFalseBoolean('Include ignored items (node_modules, etc).'),
-    multiline: defaultFalseBoolean('Multi-line mode. ^ and $ match line boundaries when isRegex=true.'),
 });
 export const ReadFileInputSchema = z
     .strictObject({
@@ -248,13 +237,13 @@ export const ReadFileInputSchema = z
     ...createReadRangeInputFields({
         head: 'Read first N lines (preview)',
         tail: 'Read last N lines',
-        startLine: 'Start line (1-based, inclusive)',
-        endLine: 'End line (1-based, inclusive). Requires startLine.',
+        startLine: 'Start line (1-based, inclusive). Defaults to 1 when endLine is set.',
+        endLine: 'End line (1-based, inclusive). Defaults to last line when startLine is set.',
     }),
     includeHash: defaultFalseBoolean('Include SHA-256 hash of full file content'),
 })
     .superRefine(validateReadRange)
-    .describe("Use one read mode only: 'head', 'tail', or 'startLine'/'endLine'. 'endLine' requires 'startLine'.");
+    .describe("Use one read mode only: 'head', 'tail', or 'startLine'/'endLine'.");
 export const ReadMultipleFilesInputSchema = z
     .strictObject({
     paths: z
@@ -265,12 +254,12 @@ export const ReadMultipleFilesInputSchema = z
     ...createReadRangeInputFields({
         head: 'Read first N lines of each file',
         tail: 'Read last N lines of each file',
-        startLine: 'Start line (1-based, inclusive) per file',
-        endLine: 'End line (1-based, inclusive) per file. Requires startLine.',
+        startLine: 'Start line (1-based, inclusive) per file. Defaults to 1 when endLine is set.',
+        endLine: 'End line (1-based, inclusive) per file. Defaults to last line when startLine is set.',
     }),
 })
     .superRefine(validateReadRange)
-    .describe("Use one read mode only: 'head', 'tail', or 'startLine'/'endLine'. 'endLine' requires 'startLine'.");
+    .describe("Use one read mode only: 'head', 'tail', or 'startLine'/'endLine'.");
 export const GetFileInfoInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
 });
@@ -282,62 +271,49 @@ export const GetMultipleFileInfoInputSchema = z.strictObject({
         .describe('File/directory paths. e.g. ["src", "lib"]'),
 });
 export const ListAllowedDirectoriesOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     directories: z.array(z.string()).optional().describe('Allowed directories'),
-    rootsCount: z.number().optional().describe('Number of roots'),
-    hasMultipleRoots: z
-        .boolean()
-        .optional()
-        .describe('Multiple roots configured'),
-    error: ErrorSchema.optional(),
 });
 export const ListDirectoryOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     path: z.string().optional(),
     entries: z
         .array(z.strictObject({
         name: z.string().describe('Entry name'),
         relativePath: z.string().optional(),
         type: FileTypeSchema,
-        size: z.number().optional(),
-        modified: z.string().optional(),
+        size: NonNegativeIntegerSchema.optional(),
+        modified: IsoDateTimeSchema.optional(),
     }))
         .optional(),
-    totalEntries: z.number().optional(),
+    totalEntries: NonNegativeIntegerSchema.optional(),
     truncated: z.boolean().optional(),
-    entriesScanned: z.number().optional(),
-    entriesVisible: z.number().optional(),
-    totalFiles: z.number().optional(),
-    totalDirectories: z.number().optional(),
-    maxDepthReached: z.number().optional(),
+    totalFiles: NonNegativeIntegerSchema.optional(),
+    totalDirectories: NonNegativeIntegerSchema.optional(),
     stoppedReason: ListDirectoryStopReasonSchema.optional(),
-    skippedInaccessible: z.number().optional(),
-    symlinksNotFollowed: z.number().optional(),
+    skippedInaccessible: NonNegativeIntegerSchema.optional(),
     nextCursor: z
         .string()
         .optional()
         .describe('Cursor for the next page; absent on the final page'),
-    error: ErrorSchema.optional(),
 });
 const SearchSummarySchema = z.strictObject({
-    totalMatches: z.number().optional().describe('Total matches found'),
+    totalMatches: NonNegativeIntegerSchema.optional().describe('Total matches found'),
     truncated: z.boolean().optional().describe('Results truncated?'),
     resourceUri: z.string().optional().describe('Full results URI'),
-    error: ErrorSchema.optional(),
 });
 export const SearchFilesOutputSchema = SearchSummarySchema.extend({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     root: z.string().optional().describe('Search root'),
-    pattern: z.string().optional().describe('Glob pattern used'),
     results: z
         .array(z.strictObject({
         path: z.string().describe('Relative path'),
-        size: z.number().optional(),
-        modified: z.string().optional(),
+        size: NonNegativeIntegerSchema.optional(),
+        modified: IsoDateTimeSchema.optional(),
     }))
         .optional(),
-    filesScanned: z.number().optional().describe('Files scanned'),
-    skippedInaccessible: z.number().optional().describe('Inaccessible files'),
+    filesScanned: NonNegativeIntegerSchema.optional().describe('Files scanned'),
+    skippedInaccessible: NonNegativeIntegerSchema.optional().describe('Inaccessible files'),
     stoppedReason: SearchStopReasonSchema.optional().describe('Why search stopped'),
     nextCursor: z
         .string()
@@ -345,70 +321,49 @@ export const SearchFilesOutputSchema = SearchSummarySchema.extend({
         .describe('Cursor for the next page; absent on the final page'),
 });
 export const SearchContentOutputSchema = SearchSummarySchema.extend({
-    ok: z.boolean(),
-    patternType: z
-        .enum(['literal', 'regex'])
-        .optional()
-        .describe('Pattern interpretation'),
-    caseSensitive: z.boolean().optional().describe('Case-sensitive matching'),
+    ok: SuccessFlagSchema,
     matches: z
         .array(z.strictObject({
         file: z.string().describe('Relative path'),
-        line: z.number(),
-        column: z
-            .number()
-            .optional()
-            .describe('Column of first match (0-based)'),
+        line: PositiveIntegerSchema,
+        column: NonNegativeIntegerSchema.optional().describe('Column of first match (0-based)'),
         content: z.string(),
-        matchCount: z.number(),
+        matchCount: PositiveIntegerSchema,
         contextBefore: z.array(z.string()).optional(),
         contextAfter: z.array(z.string()).optional(),
     }))
         .optional(),
-    filesScanned: z.number().optional().describe('Files scanned'),
-    filesMatched: z.number().optional().describe('Files with matches'),
-    skippedTooLarge: z.number().optional().describe('Files skipped: too large'),
-    skippedBinary: z.number().optional().describe('Files skipped: binary'),
-    skippedInaccessible: z
-        .number()
-        .optional()
-        .describe('Files skipped: inaccessible'),
-    linesSkippedDueToRegexTimeout: z
-        .number()
-        .optional()
-        .describe('Lines skipped due to regex timeout'),
+    filesScanned: NonNegativeIntegerSchema.optional().describe('Files scanned'),
+    filesMatched: NonNegativeIntegerSchema.optional().describe('Files with matches'),
+    skippedTooLarge: NonNegativeIntegerSchema.optional().describe('Files skipped: too large'),
+    skippedBinary: NonNegativeIntegerSchema.optional().describe('Files skipped: binary'),
+    skippedInaccessible: NonNegativeIntegerSchema.optional().describe('Files skipped: inaccessible'),
     stoppedReason: SearchStopReasonSchema.optional().describe('Why search stopped'),
 });
 export const TreeOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     root: z.string().optional(),
     tree: TreeEntrySchema.optional(),
     ascii: z.string().optional(),
     truncated: z.boolean().optional(),
-    totalEntries: z.number().optional(),
-    error: ErrorSchema.optional(),
+    totalEntries: NonNegativeIntegerSchema.optional(),
 });
 const ReadResultSchema = z.strictObject({
     content: z.string().optional().describe('Content'),
     truncated: z.boolean().optional().describe('Truncated?'),
     resourceUri: z.string().optional().describe('Full content URI'),
-    totalLines: z.number().optional().describe('Total lines'),
-    readMode: z
-        .enum(['full', 'head', 'tail', 'range'])
-        .optional()
-        .describe('Mode'),
-    head: z.number().optional().describe('Head lines'),
-    tail: z.number().optional().describe('Tail lines'),
-    startLine: z.number().optional().describe('Start line'),
-    endLine: z.number().optional().describe('End line'),
-    linesRead: z.number().optional().describe('Lines read'),
+    totalLines: NonNegativeIntegerSchema.optional().describe('Total lines'),
+    head: PositiveIntegerSchema.optional().describe('Head lines'),
+    tail: PositiveIntegerSchema.optional().describe('Tail lines'),
+    startLine: PositiveIntegerSchema.optional().describe('Start line'),
+    endLine: PositiveIntegerSchema.optional().describe('End line'),
+    linesRead: NonNegativeIntegerSchema.optional().describe('Lines read'),
     hasMoreLines: z.boolean().optional().describe('More lines?'),
 });
 export const ReadFileOutputSchema = ReadResultSchema.extend({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     path: z.string().optional(),
-    contentHash: z.string().optional().describe('SHA-256 of full file content'),
-    error: ErrorSchema.optional(),
+    contentHash: Sha256HexSchema.optional().describe('SHA-256 of full file content'),
 });
 const ReadMultipleFileResultSchema = ReadResultSchema.extend({
     path: z.string().describe('File path'),
@@ -416,60 +371,77 @@ const ReadMultipleFileResultSchema = ReadResultSchema.extend({
         .enum(['head', 'tail', 'range', 'externalized'])
         .optional()
         .describe('Why content was truncated'),
-    maxTotalSize: z.number().optional().describe('Max total size budget'),
-    error: z.string().optional().describe('Error message'),
+    error: ErrorSchema.optional().describe('Structured error details'),
 });
 export const ReadMultipleFilesOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     results: z.array(ReadMultipleFileResultSchema).optional(),
     summary: OperationSummarySchema.optional(),
-    error: ErrorSchema.optional(),
 });
 export const GetFileInfoOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     info: FileInfoSchema.optional(),
-    error: ErrorSchema.optional(),
 });
 export const GetMultipleFileInfoOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     results: z
         .array(z.strictObject({
         path: z.string(),
         info: FileInfoSchema.optional(),
-        error: z.string().optional(),
+        error: ErrorSchema.optional(),
     }))
         .optional(),
     summary: OperationSummarySchema.optional(),
-    error: ErrorSchema.optional(),
 });
 export const CreateDirectoryInputSchema = z
     .strictObject({
     path: RequiredPathSchema.optional().describe(DESC_PATH_REQUIRED),
     paths: z
         .array(RequiredPathSchema)
+        .min(1, 'Min 1 path required')
         .optional()
         .describe('Absolute paths to directories to create'),
 })
-    .refine((data) => data.path !== undefined || data.paths !== undefined, {
-    error: "Either 'path' or 'paths' must be provided",
-    path: ['path'],
+    .superRefine((data, ctx) => {
+    const hasPath = data.path !== undefined;
+    const hasPaths = data.paths !== undefined;
+    if (!hasPath && !hasPaths) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['path'],
+            message: "Either 'path' or 'paths' must be provided",
+            input: data,
+        });
+    }
+    if (hasPath && hasPaths) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['path'],
+            message: "Provide either 'path' or 'paths', not both",
+            input: data,
+        });
+        ctx.addIssue({
+            code: 'custom',
+            path: ['paths'],
+            message: "Provide either 'path' or 'paths', not both",
+            input: data,
+        });
+    }
 })
     .describe("Provide either 'path' or 'paths'.");
 export const CreateDirectoryOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     path: z.string().optional(),
     paths: z.array(z.string()).optional(),
-    error: ErrorSchema.optional(),
 });
 export const WriteFileInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
     content: z.string().describe('Content to write'),
 });
 export const WriteFileOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     path: z.string().optional(),
-    bytesWritten: z.number().optional(),
-    error: ErrorSchema.optional(),
+    bytesWritten: NonNegativeIntegerSchema.optional(),
 });
 export const EditFileInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
@@ -490,11 +462,11 @@ export const EditFileInputSchema = z.strictObject({
 export const EditFileOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
-    appliedEdits: z.number().optional(),
-    linesAdded: z.number().optional().describe('Lines added'),
-    linesRemoved: z.number().optional().describe('Lines removed'),
+    appliedEdits: NonNegativeIntegerSchema.optional(),
+    linesAdded: NonNegativeIntegerSchema.optional().describe('Lines added'),
+    linesRemoved: NonNegativeIntegerSchema.optional().describe('Lines removed'),
     lineRange: z
-        .tuple([z.number(), z.number()])
+        .tuple([PositiveIntegerSchema, PositiveIntegerSchema])
         .optional()
         .describe('Line range modified [start, end] (1-based)'),
     unmatchedEdits: z
@@ -502,17 +474,42 @@ export const EditFileOutputSchema = z.strictObject({
         .optional()
         .describe('Edits that could not be applied'),
     diff: z.string().optional().describe('Unified diff of changes (dryRun)'),
-    error: ErrorSchema.optional(),
 });
 export const MoveFileInputSchema = z
     .strictObject({
     source: RequiredPathSchema.optional().describe('Path to move (deprecated: use sources)'),
-    sources: z.array(RequiredPathSchema).optional().describe('Paths to move'),
+    sources: z
+        .array(RequiredPathSchema)
+        .min(1, 'Min 1 source required')
+        .optional()
+        .describe('Paths to move'),
     destination: RequiredPathSchema.describe('New path'),
 })
-    .refine((data) => (data.source ?? data.sources) !== undefined, {
-    error: "Either 'source' or 'sources' must be provided",
-    path: ['source'],
+    .superRefine((data, ctx) => {
+    const hasSource = data.source !== undefined;
+    const hasSources = data.sources !== undefined;
+    if (!hasSource && !hasSources) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['source'],
+            message: "Either 'source' or 'sources' must be provided",
+            input: data,
+        });
+    }
+    if (hasSource && hasSources) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['source'],
+            message: "Provide either 'source' or 'sources', not both",
+            input: data,
+        });
+        ctx.addIssue({
+            code: 'custom',
+            path: ['sources'],
+            message: "Provide either 'source' or 'sources', not both",
+            input: data,
+        });
+    }
 })
     .describe("Provide either 'source' or 'sources'.");
 export const MoveFileOutputSchema = z.strictObject({
@@ -523,11 +520,10 @@ export const MoveFileOutputSchema = z.strictObject({
     failed: z
         .array(z.strictObject({
         source: z.string().describe('Source path'),
-        error: z.string().describe('Error message'),
+        error: ErrorSchema.describe('Structured error details'),
     }))
         .optional()
         .describe('List of files that failed to move'),
-    error: ErrorSchema.optional(),
 });
 export const DeleteFileInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
@@ -535,23 +531,18 @@ export const DeleteFileInputSchema = z.strictObject({
     ignoreIfNotExists: defaultFalseBoolean('No error if missing'),
 });
 export const DeleteFileOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     path: z.string().optional(),
-    error: ErrorSchema.optional(),
 });
 export const CalculateHashInputSchema = z.strictObject({
     path: RequiredPathSchema.describe(DESC_PATH_REQUIRED),
 });
 export const CalculateHashOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     path: z.string().optional(),
-    hash: z.string().optional().describe('SHA-256 hash'),
+    hash: Sha256HexSchema.optional().describe('SHA-256 hash'),
     isDirectory: z.boolean().optional().describe('True if path is a directory'),
-    fileCount: z
-        .number()
-        .optional()
-        .describe('Number of files hashed (directories only)'),
-    error: ErrorSchema.optional(),
+    fileCount: NonNegativeIntegerSchema.optional().describe('Number of files hashed (directories only)'),
 });
 export const DiffFilesInputSchema = z.strictObject({
     original: RequiredPathSchema.describe('Path to original file'),
@@ -574,15 +565,14 @@ export const DiffFilesInputSchema = z.strictObject({
         .describe('Strip trailing carriage returns before diffing'),
 });
 export const DiffFilesOutputSchema = z.strictObject({
-    ok: z.boolean(),
+    ok: SuccessFlagSchema,
     diff: z.string().optional().describe('Unified diff content'),
     isIdentical: z.boolean().optional().describe('True if files are identical'),
-    linesAdded: z.number().optional().describe('Lines added'),
-    linesRemoved: z.number().optional().describe('Lines removed'),
-    hunksCount: z.number().optional().describe('Number of diff hunks'),
+    linesAdded: NonNegativeIntegerSchema.optional().describe('Lines added'),
+    linesRemoved: NonNegativeIntegerSchema.optional().describe('Lines removed'),
+    hunksCount: NonNegativeIntegerSchema.optional().describe('Number of diff hunks'),
     truncated: z.boolean().optional().describe('Diff content truncated?'),
     resourceUri: z.string().optional().describe('Full diff content URI'),
-    error: ErrorSchema.optional(),
 });
 export const ApplyPatchInputSchema = z.strictObject({
     path: RequiredPathSchema.describe('Path to file to patch'),
@@ -614,21 +604,20 @@ export const ApplyPatchOutputSchema = z.strictObject({
     ok: z.boolean(),
     path: z.string().optional(),
     applied: z.boolean().optional(),
-    hunksApplied: z.number().optional().describe('Hunks applied'),
-    linesAdded: z.number().optional().describe('Lines added'),
-    linesRemoved: z.number().optional().describe('Lines removed'),
+    hunksApplied: NonNegativeIntegerSchema.optional().describe('Hunks applied'),
+    linesAdded: NonNegativeIntegerSchema.optional().describe('Lines added'),
+    linesRemoved: NonNegativeIntegerSchema.optional().describe('Lines removed'),
     results: z
         .array(z.strictObject({
         path: z.string().describe('File path'),
         applied: z.boolean().describe('Patch applied successfully'),
-        hunksApplied: z.number().optional().describe('Hunks applied'),
-        linesAdded: z.number().optional().describe('Lines added'),
-        linesRemoved: z.number().optional().describe('Lines removed'),
-        error: z.string().optional().describe('Error message'),
+        hunksApplied: NonNegativeIntegerSchema.optional().describe('Hunks applied'),
+        linesAdded: NonNegativeIntegerSchema.optional().describe('Lines added'),
+        linesRemoved: NonNegativeIntegerSchema.optional().describe('Lines removed'),
+        error: ErrorSchema.optional().describe('Structured error details'),
     }))
         .optional()
         .describe('Per-file results for multi-file patches'),
-    error: ErrorSchema.optional(),
 });
 export const SearchAndReplaceInputSchema = z.strictObject({
     path: OptionalPathSchema.describe(DESC_PATH_ROOT),
@@ -675,22 +664,22 @@ export const SearchAndReplaceInputSchema = z.strictObject({
         .describe('Max files to process before stopping'),
 });
 export const SearchAndReplaceOutputSchema = z.strictObject({
-    ok: z.boolean(),
-    matches: z.number().optional().describe('Total matches found'),
-    filesChanged: z.number().optional().describe('Files modified'),
-    processedFiles: z.number().optional().describe('Files processed'),
-    failedFiles: z.number().optional().describe('Files skipped due to errors'),
+    ok: SuccessFlagSchema,
+    matches: NonNegativeIntegerSchema.optional().describe('Total matches found'),
+    filesChanged: NonNegativeIntegerSchema.optional().describe('Files modified'),
+    processedFiles: NonNegativeIntegerSchema.optional().describe('Files processed'),
+    failedFiles: NonNegativeIntegerSchema.optional().describe('Files skipped due to errors'),
     failures: z
         .array(z.strictObject({
         path: z.string().describe('File path'),
-        error: z.string().describe('Error message'),
+        error: ErrorSchema.describe('Structured error details'),
     }))
         .optional()
         .describe('Sample of per-file errors'),
     changedFiles: z
         .array(z.strictObject({
         path: z.string().describe('File path'),
-        matches: z.number().describe('Matches in file'),
+        matches: PositiveIntegerSchema.describe('Matches in file'),
     }))
         .optional()
         .describe('Sample of changed files'),
@@ -707,6 +696,4 @@ export const SearchAndReplaceOutputSchema = z.strictObject({
         .enum(['maxFiles'])
         .optional()
         .describe('Why processing stopped early'),
-    dryRun: z.boolean().optional(),
-    error: ErrorSchema.optional(),
 });

package/dist/server/bootstrap.d.ts

@@ -5,20 +5,10 @@ export interface ServerOptions {
     allowCwd?: boolean;
     cliAllowedDirs?: string[];
 }
-interface CapabilityOptions {
-    enablePromptListChanged?: boolean;
-    enableTaskToolRequests?: boolean;
-}
-type ServerCapabilities = NonNullable<ConstructorParameters<typeof McpServer>[1]>['capabilities'];
-type NonOptionalServerCapabilities = NonNullable<ServerCapabilities>;
-export declare function buildServerCapabilities(options?: CapabilityOptions): NonOptionalServerCapabilities;
-export declare function supportsTaskToolRequests(): boolean;
 export interface LoggingState {
     minimumLevel: LoggingLevel;
 }
-export declare function createLoggingState(minimumLevel?: LoggingLevel): LoggingState;
 export declare function logToMcp(server: McpServer | undefined, level: LoggingLevel, data: string, minLevel?: LoggingLevel): void;
 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 {};

package/dist/server/bootstrap.js

@@ -41,7 +41,7 @@ function detectTaskToolSupport() {
     }
     return cachedTaskToolSupport;
 }
-export function buildServerCapabilities(options = {}) {
+function buildServerCapabilities(options = {}) {
     const capabilities = {
         logging: {},
         resources: {},
@@ -61,7 +61,7 @@ export function buildServerCapabilities(options = {}) {
     }
     return capabilities;
 }
-export function supportsTaskToolRequests() {
+function supportsTaskToolRequests() {
     return detectTaskToolSupport();
 }
 const MCP_LOGGER_NAME = 'filesystem-mcp';
@@ -75,7 +75,7 @@ const LOG_LEVEL_ORDER = {
     alert: 6,
     emergency: 7,
 };
-export function createLoggingState(minimumLevel = 'debug') {
+function createLoggingState(minimumLevel = 'debug') {
     return { minimumLevel };
 }
 function canSendMcpLogs(server) {