fix(read_file): accept 'limit' as an alias for 'length'

A caller that names the page size 'limit' (Claude's Read tool naming) had the
argument silently dropped: the zod schema only knew 'length', so the whole
file came back capped only by fileReadLineLimit. Accept 'limit' as an alias,
let the configured fileReadLineLimit apply when neither name is given (the
schema default was shadowing it), and document the alias in the tool
description. Add a regression test covering limit, offset+limit, the length
precedence and the config fallback.

Author: CodeAlex52

src/handlers/filesystem-handlers.ts

@@ -101,7 +101,9 @@ export async function handleReadFile(args: unknown): Promise<ServerResult> {
         const options: ReadOptions = {
             isUrl: parsed.isUrl,
             offset: parsed.offset ?? 0,
-            length: parsed.length ?? defaultLimit,
+            // `limit` is accepted as an alias for `length` (see ReadFileArgsSchema);
+            // the configured fileReadLineLimit applies when neither is given.
+            length: parsed.length ?? parsed.limit ?? defaultLimit,
             sheet: sheetParam,
             range: parsed.range
         };

src/server.ts

@@ -372,6 +372,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - 'length' (max lines to read, default: configurable via 'fileReadLineLimit' setting, initially 1000)
                           * Used with positive offsets for range reading
                           * Ignored when offset is negative (reads all requested tail lines)
+                          * 'limit' is accepted as an alias for 'length' (some clients name it that way)
                         
                         Examples:
                         - offset: 0, length: 10     → First 10 lines

src/tools/schemas.ts

@@ -57,7 +57,13 @@ export const ReadFileArgsSchema = z.object({
   path: z.string(),
   isUrl: z.boolean().optional().default(false),
   offset: z.number().optional().default(0),
-  length: z.number().optional().default(1000),
+  // No schema default: the handler applies the configured `fileReadLineLimit`
+  // when neither `length` nor its `limit` alias is supplied.
+  length: z.number().optional(),
+  // Alias for `length`. Some clients and models call the page size `limit`
+  // (Claude's Read tool naming); without this they are silently ignored and the
+  // whole file comes back. `length` wins when both are present.
+  limit: z.number().optional(),
   sheet: z.string().optional(),  // String only for MCP client compatibility (Cursor doesn't support union types in JSON Schema)
   range: z.string().optional(),
   options: z.record(z.any()).optional(),

test/test-read-file-limit-alias.js

@@ -0,0 +1,157 @@
+/**
+ * Regression test for `read_file` ignoring the per-call page size when the
+ * caller names it `limit` instead of `length`.
+ *
+ * Issue: wonderwhy-er/DesktopCommanderMCP#686 — a caller sending
+ * `{ offset: 0, limit: 3 }` got the whole file back (capped only by
+ * fileReadLineLimit), because `limit` was not part of the argument schema and
+ * was silently dropped. The tool now accepts `limit` as an alias for `length`.
+ *
+ * This test checks:
+ * 1. `limit` alone limits the returned lines.
+ * 2. `offset` + `limit` reads the requested window.
+ * 3. `length` still works and wins when both names are present.
+ * 4. The configured fileReadLineLimit applies when neither is supplied.
+ */
+
+import { configManager } from '../dist/config-manager.js';
+import { handleReadFile } from '../dist/handlers/filesystem-handlers.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TEST_FILE = path.join(__dirname, 'test-read-file-limit-alias.txt');
+const TOTAL_LINES = 50;
+
+/**
+ * Setup: allowed directory, numbered test file, known read limit.
+ */
+async function setup() {
+  console.log('🔧 Setting up read_file limit alias test...');
+
+  const originalConfig = await configManager.getConfig();
+  await configManager.setValue('allowedDirectories', [__dirname]);
+  // Keep a non-default limit so "no page size given" is distinguishable from
+  // "page size applied".
+  await configManager.setValue('fileReadLineLimit', 7);
+
+  const content = Array.from(
+    { length: TOTAL_LINES },
+    (_, i) => `Line ${i + 1}: alias test content`
+  ).join('\n');
+  await fs.writeFile(TEST_FILE, content, 'utf8');
+
+  console.log(`✓ Created ${TOTAL_LINES}-line test file, fileReadLineLimit=7`);
+  return originalConfig;
+}
+
+async function teardown(originalConfig) {
+  console.log('🧹 Cleaning up read_file limit alias test...');
+  await configManager.updateConfig(originalConfig);
+  try {
+    await fs.rm(TEST_FILE, { force: true });
+    console.log('✓ Test file cleaned up');
+  } catch (error) {
+    console.log('⚠️  Warning: Could not clean up test file:', error.message);
+  }
+}
+
+/** Count the numbered body lines in a read_file result. */
+function countBodyLines(result) {
+  return result.content[0].text
+    .split('\n')
+    .filter(line => line.startsWith('Line ')).length;
+}
+
+async function runAllTests() {
+  console.log('🧪 Testing read_file page-size arguments (limit alias)');
+  let allTestsPassed = true;
+  let originalConfig;
+
+  try {
+    originalConfig = await setup();
+
+    const cases = [
+      {
+        name: 'limit: 3 returns 3 lines',
+        args: { path: TEST_FILE, limit: 3 },
+        expected: 3,
+      },
+      {
+        name: 'offset: 0, limit: 3 returns 3 lines',
+        args: { path: TEST_FILE, offset: 0, limit: 3 },
+        expected: 3,
+      },
+      {
+        name: 'offset: 10, limit: 5 returns 5 lines',
+        args: { path: TEST_FILE, offset: 10, limit: 5 },
+        expected: 5,
+      },
+      {
+        name: 'length: 4 still returns 4 lines',
+        args: { path: TEST_FILE, length: 4 },
+        expected: 4,
+      },
+      {
+        name: 'length wins when both length and limit are given',
+        args: { path: TEST_FILE, length: 6, limit: 2 },
+        expected: 6,
+      },
+      {
+        name: 'no page size falls back to fileReadLineLimit (7)',
+        args: { path: TEST_FILE },
+        expected: 7,
+      },
+    ];
+
+    for (const testCase of cases) {
+      console.log(`\n  🧪 ${testCase.name}`);
+      try {
+        const result = await handleReadFile(testCase.args);
+        if (result.isError) {
+          console.log(`  ❌ Error: ${result.content[0].text}`);
+          allTestsPassed = false;
+          continue;
+        }
+        const actual = countBodyLines(result);
+        if (actual === testCase.expected) {
+          console.log(`  ✅ PASS: ${actual} line(s)`);
+        } else {
+          console.log(`  ❌ FAIL: expected ${testCase.expected} line(s), got ${actual}`);
+          allTestsPassed = false;
+        }
+      } catch (error) {
+        console.log(`  ❌ Exception: ${error.message}`);
+        allTestsPassed = false;
+      }
+    }
+
+    console.log(
+      `\n🎯 Overall result: ${allTestsPassed ? '✅ ALL TESTS PASSED!' : '❌ SOME TESTS FAILED'}`
+    );
+  } catch (error) {
+    console.error('❌ Test setup/execution failed:', error.message);
+    allTestsPassed = false;
+  } finally {
+    if (originalConfig) {
+      await teardown(originalConfig);
+    }
+  }
+
+  return allTestsPassed;
+}
+
+export default runAllTests;
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runAllTests()
+    .then(success => {
+      process.exit(success ? 0 : 1);
+    })
+    .catch(error => {
+      console.error('❌ Unhandled error:', error);
+      process.exit(1);
+    });
+}