sys: map getcwd ENOENT to CurrentWorkingDirectoryUnlinked

src/bun_core/util.rs

@@ -4355,7 +4355,14 @@ pub fn getcwd(buf: &mut PathBuffer) -> Result<&ZStr, crate::Error> {
     unsafe {
         let p = libc::getcwd(buf.0.as_mut_ptr().cast(), buf.0.len());
         if p.is_null() {
-            return Err(std::io::Error::last_os_error().into());
+            let e = std::io::Error::last_os_error();
+            // Mirror Zig's `std.posix.getcwd`: ENOENT means the cwd was
+            // unlinked. `crash_handler::handle_root_error` matches on this
+            // name to print an actionable hint.
+            if e.raw_os_error() == Some(libc::ENOENT) {
+                return Err(crate::err!("CurrentWorkingDirectoryUnlinked"));
+            }
+            return Err(e.into());
         }
         let len = libc::strlen(p);
         Ok(ZStr::from_buf(&buf.0, len))

src/sys/Error.rs

@@ -325,6 +325,13 @@ impl Error {
     }
 
     pub fn to_zig_err(&self) -> bun_core::Error {
+        // Zig's `std.posix.getcwd` maps ENOENT to the named error
+        // `CurrentWorkingDirectoryUnlinked`; preserve that name so
+        // `crash_handler::handle_root_error` can print the actionable hint
+        // instead of falling through to the generic ENOENT message.
+        if self.syscall == Tag::getcwd && self.get_errno() == E::ENOENT {
+            return bun_core::err!("CurrentWorkingDirectoryUnlinked");
+        }
         errno_to_err(self.errno)
     }
 

src/sys/lib.rs

@@ -31,8 +31,10 @@ pub use error::ReturnCodeExt;
 impl From<Error> for bun_core::Error {
     #[inline]
     fn from(e: Error) -> bun_core::Error {
-        // Encode as the errno's name (e.g., "ENOENT") in the interned table.
-        bun_core::Error::from_errno(e.errno as i32)
+        // Route through `to_zig_err` so syscall-specific errno→name mappings
+        // (e.g. getcwd+ENOENT → CurrentWorkingDirectoryUnlinked) apply to `?`
+        // conversions as well.
+        e.to_zig_err()
     }
 }
 /// The JS-facing rich error

test/bundler/bun-build-compile.test.ts

@@ -568,10 +568,11 @@ describe("compiled binary in a deleted cwd", () => {
       });
       const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
 
-      // The entry never runs (VM init aborts first), the ENOENT surfaces, and the
-      // process exits 1 — a crash would terminate via a signal, never exit 1.
+      // The entry never runs (VM init aborts first), the getcwd ENOENT surfaces
+      // as the cwd-deleted hint, and the process exits 1 — a crash would
+      // terminate via a signal, never exit 1.
       expect(stdout).toBe("");
-      expect(stderr).toContain("ENOENT");
+      expect(stderr).toContain("The current working directory was deleted");
       expect(exitCode).toBe(1);
     },
     60_000,

test/cli/run/run-crash-handler.test.ts

@@ -1,6 +1,6 @@
 import { crash_handler } from "bun:internal-for-testing";
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isDebug, isLinux, isPosix, mergeWindowEnvs } from "harness";
+import { bunEnv, bunExe, isDebug, isLinux, isPosix, mergeWindowEnvs, tempDir } from "harness";
 import path from "path";
 const { getMachOImageZeroOffset } = crash_handler;
 
@@ -83,6 +83,44 @@ test.if(isPosix)(
   20_000,
 );
 
+// `handle_root_error` recognizes the named error `CurrentWorkingDirectoryUnlinked`
+// and prints an actionable hint. Zig's stdlib mapped `getcwd` ENOENT to that name;
+// the Rust `bun_sys::Error` → `bun_core::Error` conversion dropped the syscall tag
+// and emitted a bare "ENOENT", so the hint was unreachable and users saw the
+// generic "Bun could not find a file" fallback instead.
+//
+// POSIX-only: Windows refuses to remove a directory that is any process's cwd.
+describe.if(isPosix)("cwd deleted before startup", () => {
+  for (const cmd of [
+    ["-e", "console.log(1)"],
+    ["run", "foo"],
+  ]) {
+    test(`bun ${cmd[0]} prints the cwd-deleted hint`, async () => {
+      using dir = tempDir("cwd-unlinked", {});
+      const gone = String(dir);
+
+      await using proc = Bun.spawn({
+        cmd: [
+          "/bin/sh",
+          "-c",
+          `cd "${gone}" && rmdir "${gone}" && exec "${bunExe()}" ${cmd.map(a => `'${a}'`).join(" ")}`,
+        ],
+        env: bunEnv,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+      expect({ stdout, stderr, exitCode }).toEqual({
+        stdout: "",
+        stderr: expect.stringContaining("The current working directory was deleted"),
+        exitCode: 1,
+      });
+      expect(stderr).not.toContain("Bun could not find a file");
+    });
+  }
+});
+
 test.if(process.platform === "darwin")("macOS has the assumed image offset", () => {
   // If this fails, then https://bun.report will be incorrect and the stack
   // trace remappings will stop working.