getcwd: report CurrentWorkingDirectoryUnlinked from a deleted cwd again

src/bun_core/error.rs

@@ -25,6 +25,8 @@ pub enum Error {
     AccessDenied,
     #[error("WriteFailed")]
     WriteFailed,
+    #[error("CurrentWorkingDirectoryUnlinked")]
+    CurrentWorkingDirectoryUnlinked,
     #[error(transparent)]
     Alloc(#[from] bun_alloc::AllocError),
 }
@@ -45,6 +47,7 @@ impl Error {
             Self::FileNotFound => "FileNotFound",
             Self::AccessDenied => "AccessDenied",
             Self::WriteFailed => "WriteFailed",
+            Self::CurrentWorkingDirectoryUnlinked => "CurrentWorkingDirectoryUnlinked",
             Self::Alloc(_) => "OutOfMemory",
         }
     }

src/bun_core/util.rs

@@ -4165,6 +4165,9 @@ fn getcwd_len(buf: &mut PathBuffer) -> crate::CrateResult<usize> {
     unsafe {
         let p = libc::getcwd(buf.0.as_mut_ptr().cast(), buf.0.len());
         if p.is_null() {
+            if crate::ffi::errno() == libc::ENOENT {
+                return Err(crate::CrateError::CurrentWorkingDirectoryUnlinked);
+            }
             return Err(crate::CrateError::Unexpected);
         }
         Ok(libc::strlen(p))

src/resolver/lib.rs

@@ -282,8 +282,7 @@ pub mod fs {
                 Some(d) => DirnameStore::instance().append_slice(d)?,
                 None => {
                     let mut buf = bun_paths::PathBuffer::default();
-                    let n = bun_sys::getcwd(&mut buf[..])?;
-                    DirnameStore::instance().append_slice(&buf[..n])?
+                    DirnameStore::instance().append_slice(bun_core::getcwd(&mut buf)?.as_bytes())?
                 }
             };
             // Seed the lower-tier `bun_paths::fs::FileSystem` singleton with the

src/runtime/cli/Arguments.rs

@@ -834,8 +834,7 @@
         let base: &[u8] = if bun_paths::is_absolute(cwd_arg) {
             b"/"
         } else {
-            let len = bun_sys::getcwd(&mut *outbuf)?;
-            &outbuf[..len]
+            bun_core::getcwd(&mut outbuf)?.as_bytes()
         };
         let out = resolve_path::join_abs::<platform::Loose>(base, cwd_arg);
         // `chdir` wants a NUL-terminated path; `join_abs` returns a borrowed
@@ -869,8 +868,7 @@
         // Everything else (install/test/build/...) must not silently act on
         // whatever project happens to live above the executable.
         let mut temp = PathBuffer::uninit();
-        let len = bun_sys::getcwd(&mut *temp)?;
-        Box::<[u8]>::from(&temp[..len])
+        Box::<[u8]>::from(bun_core::getcwd(&mut temp)?.as_bytes())
     };
 
     // Not gated on .BunxCommand: bunx skips Arguments.parse entirely

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

@@ -758,10 +758,8 @@ 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.
       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

@@ -129,6 +129,46 @@ describe.if(isPosix)("terminal signal reflects the crash cause", () => {
   });
 });
 
+// POSIX-only: Windows refuses to remove a directory that is any process's cwd.
+describe.if(isPosix)("cwd deleted before startup", () => {
+  test.concurrent.each(["install", "test"])("bun %s prints the cwd-deleted hint", async cmd => {
+    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}'`],
+      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.concurrent("bun -e boots via the exe-dir fallback instead", async () => {
+    using dir = tempDir("cwd-unlinked-run", {});
+    const gone = String(dir);
+
+    await using proc = Bun.spawn({
+      cmd: ["/bin/sh", "-c", `cd "${gone}" && rmdir "${gone}" && exec "${bunExe()}" -e 'console.log(1)'`],
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+    expect(stdout).toBe("1\n");
+    expect(stderr).toBe("");
+    expect(exitCode).toBe(0);
+  });
+});
+
 // Windows: the VEH handler must walk the stack from the fault CONTEXT record
 // (RtlVirtualUnwind), not from inside the handler. When the fault is in an
 // external DLL the old RtlCaptureStackBackTrace path could stop at