fix(npm): set up node_modules/.bin/ entries for package that provide bin entrypoints (#23496)

Closes https://github.com/denoland/deno/issues/23036

---------

Co-authored-by: Nathan Whitaker <nathan@deno.com>

cli/npm/managed/resolvers/local.rs

@@ -2,6 +2,8 @@
 
 //! Code for local node_modules resolution.
 
+mod bin_entries;
+
 use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::collections::HashMap;
@@ -24,6 +26,7 @@ use deno_ast::ModuleSpecifier;
 use deno_core::anyhow::bail;
 use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
+use deno_core::parking_lot::Mutex;
 use deno_core::unsync::spawn;
 use deno_core::unsync::JoinHandle;
 use deno_core::url::Url;
@@ -262,6 +265,10 @@ async fn sync_resolution_with_fs(
   fs::create_dir_all(&deno_node_modules_dir).with_context(|| {
     format!("Creating '{}'", deno_local_registry_dir.display())
   })?;
+  let bin_node_modules_dir_path = root_node_modules_dir_path.join(".bin");
+  fs::create_dir_all(&bin_node_modules_dir_path).with_context(|| {
+    format!("Creating '{}'", bin_node_modules_dir_path.display())
+  })?;
 
   let single_process_lock = LaxSingleProcessFsFlag::lock(
     deno_local_registry_dir.join(".deno.lock"),
@@ -286,6 +293,7 @@ async fn sync_resolution_with_fs(
     Vec::with_capacity(package_partitions.packages.len());
   let mut newest_packages_by_name: HashMap<&String, &NpmResolutionPackage> =
     HashMap::with_capacity(package_partitions.packages.len());
+  let bin_entries_to_setup = Arc::new(Mutex::new(Vec::with_capacity(16)));
   for package in &package_partitions.packages {
     if let Some(current_pkg) =
       newest_packages_by_name.get_mut(&package.id.nv.name)
@@ -313,6 +321,7 @@ async fn sync_resolution_with_fs(
       let pb = progress_bar.clone();
       let cache = cache.clone();
       let package = package.clone();
+      let bin_entries_to_setup = bin_entries_to_setup.clone();
       let handle = spawn(async move {
         cache.ensure_package(&package.id.nv, &package.dist).await?;
         let pb_guard = pb.update_with_prompt(
@@ -334,6 +343,13 @@ async fn sync_resolution_with_fs(
         }
         // write out a file that indicates this folder has been initialized
         fs::write(initialized_file, "")?;
+
+        if package.bin.is_some() {
+          bin_entries_to_setup
+            .lock()
+            .push((package.clone(), package_path));
+        }
+
         // finally stop showing the progress bar
         drop(pb_guard); // explicit for clarity
         Ok(())
@@ -464,6 +480,50 @@ async fn sync_resolution_with_fs(
     }
   }
 
+  // 6. Set up `node_modules/.bin` entries for packages that need it.
+  {
+    let bin_entries = bin_entries_to_setup.lock();
+    if !bin_entries.is_empty() && !bin_node_modules_dir_path.exists() {
+      fs::create_dir_all(&bin_node_modules_dir_path).with_context(|| {
+        format!("Creating '{}'", bin_node_modules_dir_path.display())
+      })?;
+    }
+    for (package, package_path) in &*bin_entries {
+      let package = snapshot.package_from_id(&package.id).unwrap();
+      if let Some(bin_entries) = &package.bin {
+        match bin_entries {
+          deno_npm::registry::NpmPackageVersionBinEntry::String(script) => {
+            // the default bin name doesn't include the organization
+            let name = package
+              .id
+              .nv
+              .name
+              .rsplit_once('/')
+              .map_or(package.id.nv.name.as_str(), |(_, name)| name);
+            bin_entries::set_up_bin_entry(
+              package,
+              name,
+              script,
+              package_path,
+              &bin_node_modules_dir_path,
+            )?;
+          }
+          deno_npm::registry::NpmPackageVersionBinEntry::Map(entries) => {
+            for (name, script) in entries {
+              bin_entries::set_up_bin_entry(
+                package,
+                name,
+                script,
+                package_path,
+                &bin_node_modules_dir_path,
+              )?;
+            }
+          }
+        }
+      }
+    }
+  }
+
   setup_cache.save();
   drop(single_process_lock);
   drop(pb_clear_guard);

cli/npm/managed/resolvers/local/bin_entries.rs

@@ -0,0 +1,109 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+use crate::npm::managed::NpmResolutionPackage;
+use deno_core::anyhow::Context;
+use deno_core::error::AnyError;
+use std::path::Path;
+
+pub(super) fn set_up_bin_entry(
+  package: &NpmResolutionPackage,
+  bin_name: &str,
+  #[allow(unused_variables)] bin_script: &str,
+  #[allow(unused_variables)] package_path: &Path,
+  bin_node_modules_dir_path: &Path,
+) -> Result<(), AnyError> {
+  #[cfg(windows)]
+  {
+    set_up_bin_shim(package, bin_name, bin_node_modules_dir_path)?;
+  }
+  #[cfg(unix)]
+  {
+    symlink_bin_entry(
+      package,
+      bin_name,
+      bin_script,
+      package_path,
+      bin_node_modules_dir_path,
+    )?;
+  }
+  Ok(())
+}
+
+#[cfg(windows)]
+fn set_up_bin_shim(
+  package: &NpmResolutionPackage,
+  bin_name: &str,
+  bin_node_modules_dir_path: &Path,
+) -> Result<(), AnyError> {
+  use std::fs;
+  let mut cmd_shim = bin_node_modules_dir_path.join(bin_name);
+
+  cmd_shim.set_extension("cmd");
+  let shim = format!("@deno run -A npm:{}/{bin_name} %*", package.id.nv);
+  if cmd_shim.exists() {
+    if let Ok(contents) = fs::read_to_string(cmd_shim) {
+      if contents == shim {
+        // up to date
+        return Ok(());
+      }
+    }
+    return Ok(());
+  }
+  fs::write(&cmd_shim, shim).with_context(|| {
+    format!("Can't set up '{}' bin at {}", bin_name, cmd_shim.display())
+  })?;
+
+  Ok(())
+}
+
+#[cfg(unix)]
+fn symlink_bin_entry(
+  _package: &NpmResolutionPackage,
+  bin_name: &str,
+  bin_script: &str,
+  package_path: &Path,
+  bin_node_modules_dir_path: &Path,
+) -> Result<(), AnyError> {
+  use std::os::unix::fs::symlink;
+  let link = bin_node_modules_dir_path.join(bin_name);
+  let original = package_path.join(bin_script);
+
+  // Don't bother setting up another link if it already exists
+  if link.exists() {
+    let resolved = std::fs::read_link(&link).ok();
+    if let Some(resolved) = resolved {
+      if resolved != original {
+        log::warn!(
+          "{} Trying to set up '{}' bin for \"{}\", but an entry pointing to \"{}\" already exists. Skipping...", 
+          deno_terminal::colors::yellow("Warning"), 
+          bin_name,
+          resolved.display(),
+          original.display()
+        );
+      }
+      return Ok(());
+    }
+  }
+
+  use std::os::unix::fs::PermissionsExt;
+  let mut perms = std::fs::metadata(&original).unwrap().permissions();
+  if perms.mode() & 0o111 == 0 {
+    // if the original file is not executable, make it executable
+    perms.set_mode(perms.mode() | 0o111);
+    std::fs::set_permissions(&original, perms).with_context(|| {
+      format!("Setting permissions on '{}'", original.display())
+    })?;
+  }
+  let original_relative =
+    crate::util::path::relative_path(bin_node_modules_dir_path, &original)
+      .unwrap_or(original);
+  symlink(&original_relative, &link).with_context(|| {
+    format!(
+      "Can't set up '{}' bin at {}",
+      bin_name,
+      original_relative.display()
+    )
+  })?;
+
+  Ok(())
+}