fix(ext/process): tolerate unlinked cwd and accept top-level --interactive Node compat flag

cli/args/flags.rs

@@ -1913,9 +1913,17 @@ pub fn flags_from_vec_with_initial_cwd(
       }
     }
     _ => {
+      // Node.js compatibility: `--interactive` / `-i` at the top level
+      // forces REPL mode regardless of any other flags.
+      let interactive_flag = matches
+        .try_get_one::<bool>("interactive")
+        .ok()
+        .flatten()
+        .copied()
+        .unwrap_or(false);
       let has_non_globals = app
         .get_arguments()
-        .filter(|arg| !arg.is_global_set())
+        .filter(|arg| !arg.is_global_set() && arg.get_id() != "interactive")
         .any(|arg| {
           matches
             .value_source(arg.get_id().as_str())
@@ -1924,7 +1932,9 @@ pub fn flags_from_vec_with_initial_cwd(
             })
         });
 
-      if has_non_globals || matches.contains_id("script_arg") {
+      if !interactive_flag
+        && (has_non_globals || matches.contains_id("script_arg"))
+      {
         run_parse(&mut flags, &mut matches, app, true)?;
       } else {
         handle_repl_flags(
@@ -2137,6 +2147,19 @@ pub fn clap_root() -> Command {
         .action(ArgAction::SetTrue)
         .global(true),
     )
+    .arg(
+      // Node.js compatibility: `node --interactive` / `node -i` forces REPL
+      // mode. We accept it as a no-op flag at the top level so that scripts
+      // spawning the binary the same way fall through to Deno's default
+      // REPL behavior. Deliberately not global() — only valid when no
+      // subcommand is given.
+      Arg::new("interactive")
+        .short('i')
+        .long("interactive")
+        .help("Enter REPL mode (Node.js compatibility)")
+        .action(ArgAction::SetTrue)
+        .hide(true),
+    )
     .subcommand(run_subcommand())
     .subcommand(serve_subcommand())
     .defer(|cmd| {

cli/factory.rs

@@ -698,6 +698,20 @@ impl CliFactory {
     self.services.workspace_factory.get_or_try_init(|| {
       let initial_cwd = match self.overrides.initial_cwd.clone() {
         Some(v) => v,
+        // For modes that don't depend on a real cwd (REPL, eval), fall back
+        // to a sentinel path when current_dir() fails — matches Node.js
+        // semantics where `node --interactive` works even after the cwd has
+        // been unlinked.
+        None
+          if matches!(
+            self.flags.subcommand,
+            DenoSubcommand::Repl(_) | DenoSubcommand::Eval(_)
+          ) =>
+        {
+          crate::util::env::resolve_cwd_or_fallback(
+            self.flags.initial_cwd.as_deref(),
+          )
+        }
         None => {
           crate::util::env::resolve_cwd(self.flags.initial_cwd.as_deref())?
             .into_owned()

cli/util/env.rs

@@ -6,6 +6,7 @@ use std::collections::HashSet;
 use std::env;
 use std::ffi::OsString;
 use std::path::Path;
+use std::path::PathBuf;
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::sync::OnceLock;
@@ -32,6 +33,32 @@ pub fn resolve_cwd(
   }
 }
 
+/// Like `resolve_cwd`, but falls back to a sensible default (the system
+/// root) when the current working directory can't be determined — for
+/// example when it has been unlinked. This matches Node.js semantics where
+/// the REPL still starts even if the parent process's cwd was deleted.
+pub fn resolve_cwd_or_fallback(initial_cwd: Option<&Path>) -> PathBuf {
+  match resolve_cwd(initial_cwd) {
+    Ok(cwd) => cwd.into_owned(),
+    Err(_) => fallback_cwd(),
+  }
+}
+
+fn fallback_cwd() -> PathBuf {
+  if cfg!(windows) {
+    // System drive root, e.g. `C:\`.
+    std::env::var_os("SystemDrive")
+      .map(|d| {
+        let mut p = PathBuf::from(d);
+        p.push("\\");
+        p
+      })
+      .unwrap_or_else(|| PathBuf::from("C:\\"))
+  } else {
+    PathBuf::from("/")
+  }
+}
+
 #[derive(Debug, Clone)]
 struct WatchEnvTrackerInner {
   // Track all loaded variables and their values

ext/process/lib.rs

@@ -576,7 +576,9 @@ fn create_command(
     command.args(args.args);
   }
 
-  command.current_dir(run_env.cwd);
+  if let Some(cwd) = run_env.cwd {
+    command.current_dir(cwd);
+  }
   command.env_clear();
   command.envs(run_env.envs.into_iter().map(|(k, v)| (k.into_inner(), v)));
 
@@ -1138,7 +1140,10 @@ impl std::cmp::PartialEq for EnvVarKey {
 
 struct RunEnv {
   envs: HashMap<EnvVarKey, OsString>,
-  cwd: PathBuf,
+  /// `None` means "inherit the parent's cwd". This happens when no cwd was
+  /// explicitly passed and the current working directory could not be
+  /// resolved (e.g. because it was unlinked, matching Node.js semantics).
+  cwd: Option<PathBuf>,
 }
 
 /// Computes the current environment, which will then be used to inform
@@ -1155,11 +1160,21 @@ fn compute_run_env(
     clippy::disallowed_methods,
     reason = "ok for now because launching a sub process requires the real fs"
   )]
-  let cwd =
-    std::env::current_dir().map_err(ProcessError::FailedResolvingCwd)?;
-  let cwd = arg_cwd
-    .map(|cwd_arg| resolve_path(cwd_arg, &cwd))
-    .unwrap_or(cwd);
+  let current_dir = std::env::current_dir();
+  let cwd = match arg_cwd {
+    Some(cwd_arg) => {
+      let arg_path = Path::new(cwd_arg);
+      if arg_path.is_absolute() {
+        Some(
+          deno_path_util::normalize_path(Cow::Borrowed(arg_path)).into_owned(),
+        )
+      } else {
+        let base = current_dir.map_err(ProcessError::FailedResolvingCwd)?;
+        Some(resolve_path(cwd_arg, &base))
+      }
+    }
+    None => current_dir.ok(),
+  };
   let envs = if arg_clear_env {
     arg_envs
       .iter()
@@ -1182,14 +1197,25 @@ fn resolve_cmd(cmd: &str, env: &RunEnv) -> Result<PathBuf, ProcessError> {
   #[cfg(windows)]
   let is_path = is_path || cmd.contains('\\') || Path::new(&cmd).is_absolute();
   if is_path {
-    Ok(resolve_path(cmd, &env.cwd))
+    let cmd_path = Path::new(cmd);
+    if cmd_path.is_absolute() {
+      Ok(deno_path_util::normalize_path(Cow::Borrowed(cmd_path)).into_owned())
+    } else {
+      let cwd = env.cwd.as_deref().ok_or_else(|| {
+        ProcessError::FailedResolvingCwd(std::io::Error::from(
+          std::io::ErrorKind::NotFound,
+        ))
+      })?;
+      Ok(resolve_path(cmd, cwd))
+    }
   } else {
     let path = env.envs.get(&EnvVarKey::new(OsString::from("PATH")));
+    let lookup_cwd = env.cwd.clone().unwrap_or_else(|| PathBuf::from("."));
     match deno_permissions::which::which_in(
       sys_traits::impls::RealSys,
       cmd,
       path.cloned(),
-      env.cwd.clone(),
+      lookup_cwd,
     ) {
       Ok(cmd) => Ok(cmd),
       Err(deno_permissions::which::Error::CannotFindBinaryPath) => {
@@ -1665,7 +1691,9 @@ mod deprecated {
     for arg in args.iter().skip(1) {
       c.arg(arg);
     }
-    c.current_dir(run_env.cwd);
+    if let Some(cwd) = run_env.cwd {
+      c.current_dir(cwd);
+    }
 
     c.env_clear();
     for (key, value) in run_env.envs {

tests/node_compat/config.jsonc

@@ -560,6 +560,7 @@
     "parallel/test-crypto-verify-failure.js": {},
     "parallel/test-crypto-webcrypto-aes-decrypt-tag-too-small.js": {},
     "parallel/test-crypto-worker-thread.js": {},
+    "parallel/test-cwd-enoent-repl.js": {},
     "parallel/test-datetime-change-notify.js": {},
     "parallel/test-debugger-address.mjs": {
       "ignore": true,