@@ -0,0 +1,5 @@
+---
+"@modelcontextprotocol/server-filesystem": patch
+---
+
+A write into a directory that does not exist (`write_file`, `append_file`, `move_file`, `copy_file`) now fails with `Parent directory does not exist: <directory>` instead of a raw `chdir` error that showed the server's working directory. Any other failure to enter a directory names only that directory.
@@ -147,6 +147,10 @@ Files inside the allowed directories are also [resources](https://modelcontextpr
   - Inputs:
     - `path` (string): File location
     - `content` (string): File content
+  - Does not create directories: when the file's directory does not exist, it
+    fails with `Parent directory does not exist: <directory>`; create the
+    directory first with `create_directory`. `append_file`, `move_file` and
+    `copy_file` fail the same way for a missing destination directory
   - An existing file is overwritten in place, so it keeps its inode, creation
     time, hard links and permissions (`edit_file` writes the same way). The
     overwrite is not crash-atomic: a crash mid-write can leave the file partly
 
@@ -214,7 +214,9 @@ describe("append_file", () => {
       content: "x",
     });
     expect(result.isError).toBe(true);
-    expect(textOf(result)).toMatch(/ENOENT/);
+    expect(textOf(result)).toBe(
+      `Parent directory does not exist: ${path.join(dir, "missing")}`,
+    );
     expect(fsSync.existsSync(path.join(dir, "missing"))).toBe(false);
   });
 
 
@@ -0,0 +1,179 @@
+// A write whose parent directory is missing reports the documented
+// "Parent directory does not exist: <path>" error (#5432), never the raw
+// chdir error of the pinned write, which named chdir (an implementation
+// detail) and the server's own working directory (wherever it was launched,
+// possibly outside the allowed directories). The protocol-level tests drive
+// each pinned write through a client; the unit tests below them cover the
+// error mapping's other branches in pinned-directory.ts directly.
+
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { Client } from "@modelcontextprotocol/client";
+import { createFileInDirectory } from "../pinned-directory.js";
+import {
+  call,
+  connect,
+  makeTempDir,
+  quietStderr,
+  textOf,
+  type Connected,
+} from "./helpers.js";
+
+let dir: string;
+let cwd: string;
+let conn: Connected;
+let client: Client;
+
+beforeEach(async () => {
+  quietStderr();
+  cwd = process.cwd();
+  dir = await makeTempDir("mcp-fs-missing-parent-");
+  conn = await connect([dir]);
+  client = conn.client;
+});
+
+afterEach(async () => {
+  vi.restoreAllMocks();
+  process.chdir(cwd);
+  await conn.close();
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+/** The error text must not leak the server's working directory or chdir. */
+function expectNoLeak(text: string): void {
+  expect(text).not.toContain(cwd);
+  expect(text).not.toMatch(/chdir/);
+}
+
+describe("a write into a missing directory (#5432)", () => {
+  it("write_file reports the missing parent", async () => {
+    const missing = path.join(dir, "nope");
+    const result = await call(client, "write_file", {
+      path: path.join(missing, "x.txt"),
+      content: "z",
+    });
+    expect(result.isError).toBe(true);
+    expect(textOf(result)).toBe(`Parent directory does not exist: ${missing}`);
+    expect(fsSync.existsSync(missing)).toBe(false);
+  });
+
+  it("write_file reports the missing parent several levels down", async () => {
+    const missing = path.join(dir, "no", "such");
+    const result = await call(client, "write_file", {
+      path: path.join(missing, "file.txt"),
+      content: "z",
+    });
+    expect(result.isError).toBe(true);
+    expect(textOf(result)).toBe(`Parent directory does not exist: ${missing}`);
+  });
+
+  it("append_file reports the missing parent", async () => {
+    const missing = path.join(dir, "nope");
+    const result = await call(client, "append_file", {
+      path: path.join(missing, "x.txt"),
+      content: "z",
+    });
+    expect(result.isError).toBe(true);
+    expect(textOf(result)).toBe(`Parent directory does not exist: ${missing}`);
+    expect(fsSync.existsSync(missing)).toBe(false);
+  });
+
+  it("move_file reports the destination's missing parent", async () => {
+    const source = path.join(dir, "a.txt");
+    await fs.writeFile(source, "a");
+    const missing = path.join(dir, "nope");
+    const result = await call(client, "move_file", {
+      source,
+      destination: path.join(missing, "a.txt"),
+    });
+    expect(result.isError).toBe(true);
+    expect(textOf(result)).toBe(`Parent directory does not exist: ${missing}`);
+    expect(await fs.readFile(source, "utf-8")).toBe("a");
+  });
+
+  it("copy_file reports the destination's missing parent", async () => {
+    const source = path.join(dir, "a.txt");
+    await fs.writeFile(source, "a");
+    const missing = path.join(dir, "nope");
+    const result = await call(client, "copy_file", {
+      source,
+      destination: path.join(missing, "a.txt"),
+    });
+    expect(result.isError).toBe(true);
+    expect(textOf(result)).toBe(`Parent directory does not exist: ${missing}`);
+    expect(fsSync.existsSync(missing)).toBe(false);
+  });
+
+  it("edit_file on a file in a missing directory leaks nothing", async () => {
+    const result = await call(client, "edit_file", {
+      path: path.join(dir, "nope", "x.txt"),
+      edits: [{ oldText: "a", newText: "b" }],
+    });
+    expect(result.isError).toBe(true);
+    expectNoLeak(textOf(result));
+  });
+
+  it("create_directory still creates missing parents, and leaks nothing on a file in the way", async () => {
+    const created = await call(client, "create_directory", {
+      path: path.join(dir, "a", "b"),
+    });
+    expect(created.isError).toBeFalsy();
+    await fs.writeFile(path.join(dir, "file"), "");
+    const result = await call(client, "create_directory", {
+      path: path.join(dir, "file", "below"),
+    });
+    expect(result.isError).toBe(true);
+    expectNoLeak(textOf(result));
+  });
+});
+
+describe("the pinned write's error for a directory it cannot enter", () => {
+  it("reports a file in place of the parent as a missing parent", async () => {
+    await fs.writeFile(path.join(dir, "file"), "");
+    const parent = path.join(dir, "file");
+    await expect(
+      createFileInDirectory(path.join(parent, "x.txt"), "z"),
+    ).rejects.toThrow(
+      expect.objectContaining({
+        message: `Parent directory does not exist: ${parent}`,
+        code: "ENOTDIR",
+      }),
+    );
+  });
+
+  it("keeps any other failure's code and names only the directory", async () => {
+    const realChdir = process.chdir.bind(process);
+    vi.spyOn(process, "chdir").mockImplementation((directory) => {
+      if (directory === dir) {
+        throw Object.assign(
+          new Error(`EACCES: permission denied, chdir '${cwd}' -> '${dir}'`),
+          { code: "EACCES" },
+        );
+      }
+      realChdir(directory);
+    });
+    await expect(
+      createFileInDirectory(path.join(dir, "x.txt"), "z"),
+    ).rejects.toThrow(
+      expect.objectContaining({
+        message: `EACCES: cannot enter directory: ${dir}`,
+        code: "EACCES",
+      }),
+    );
+  });
+
+  it("reports a failure with no code without leaking its message", async () => {
+    const realChdir = process.chdir.bind(process);
+    vi.spyOn(process, "chdir").mockImplementation((directory) => {
+      if (directory === dir) {
+        throw new Error(`chdir '${cwd}' -> '${dir}'`);
+      }
+      realChdir(directory);
+    });
+    await expect(
+      createFileInDirectory(path.join(dir, "x.txt"), "z"),
+    ).rejects.toThrow(`Error: cannot enter directory: ${dir}`);
+  });
+});
@@ -854,13 +854,15 @@ describe("write_file", () => {
     expect(textOf(result)).toBe("EIO: i/o error");
   });
 
-  it("reports a missing parent directory as ENOENT", async () => {
+  it("reports a missing parent directory (#5432)", async () => {
     const result = await call(client, "write_file", {
       path: path.join(dir, "no", "such", "file.txt"),
       content: "x",
     });
     expect(result.isError).toBe(true);
-    expect(textOf(result)).toMatch(/^ENOENT: no such file or directory/);
+    expect(textOf(result)).toBe(
+      `Parent directory does not exist: ${path.join(dir, "no", "such")}`,
+    );
   });
 });
 
 
@@ -162,8 +162,31 @@ function verifyWorkingDirectory(directory: string): void {
   }
 }
 
+/**
+ * The error for a directory the process could not enter (#5432). Node's chdir
+ * error names the working directory it left, which is wherever the server was
+ * launched from and none of the client's business, and names chdir, an
+ * implementation detail of the anchor. A missing directory (ENOENT, or
+ * ENOTDIR for a file in its place) is the parent of the entry being written,
+ * so it gets validatePath's message for a missing parent; anything else keeps
+ * its code and names only the directory. The code stays on the error, so a
+ * caller that branches on it (createDirectoryInPlace) still can.
+ */
+function cannotEnterError(directory: string, error: unknown): Error {
+  const code = (error as NodeJS.ErrnoException).code;
+  const message =
+    code === "ENOENT" || code === "ENOTDIR"
+      ? `Parent directory does not exist: ${directory}`
+      : `${code ?? "Error"}: cannot enter directory: ${directory}`;
+  return Object.assign(new Error(message), { code });
+}
+
 function enterDirectory(directory: string): void {
-  process.chdir(directory);
+  try {
+    process.chdir(directory);
+  } catch (error) {
+    throw cannotEnterError(directory, error);
+  }
   verifyWorkingDirectory(directory);
 }
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@modelcontextprotocol/server-filesystem": patch
 +---
++
 +A write into a directory that does not exist (`write_file`, `append_file`, `move_file`, `copy_file`) now fails with `Parent directory does not exist: <directory>` instead of a raw `chdir` error that showed the server's working directory. Any other failure to enter a directory names only that directory.