feat: Handle package.json lifecycle scripts

cli/Cargo.toml

@@ -72,12 +72,12 @@ deno_emit = "=0.40.1"
 deno_graph = { version = "=0.74.0", features = ["tokio_executor"] }
 deno_lint = { version = "=0.58.4", features = ["docs"] }
 deno_lockfile.workspace = true
-deno_npm = "=0.18.0"
+deno_npm = "=0.19.0"
 deno_runtime = { workspace = true, features = ["include_js_files_for_snapshotting"] }
 deno_semver = "=0.5.4"
 deno_task_shell = "=0.16.0"
 deno_terminal.workspace = true
-eszip = "=0.68.2"
+eszip = "=0.68.3"
 napi_sym.workspace = true
 
 async-trait.workspace = true

cli/args/flags.rs

@@ -33,6 +33,7 @@ use std::str::FromStr;
 use crate::util::fs::canonicalize_path;
 
 use super::flags_net;
+use super::DENO_FUTURE;
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct FileFlags {
@@ -824,8 +825,15 @@ impl Flags {
         std::env::current_dir().ok()
       }
       Add(_) | Bundle(_) | Completions(_) | Doc(_) | Fmt(_) | Init(_)
-      | Install(_) | Uninstall(_) | Jupyter(_) | Lsp | Lint(_) | Types
-      | Upgrade(_) | Vendor(_) => None,
+      | Uninstall(_) | Jupyter(_) | Lsp | Lint(_) | Types | Upgrade(_)
+      | Vendor(_) => None,
+      Install(_) => {
+        if *DENO_FUTURE {
+          std::env::current_dir().ok()
+        } else {
+          None
+        }
+      }
     }
   }
 
@@ -2002,25 +2010,36 @@ The installation root is determined, in order of precedence:
   - $HOME/.deno
 
 These must be added to the path manually if required.")
-    .defer(|cmd| runtime_args(cmd, true, true).arg(Arg::new("cmd").required(true).num_args(1..).value_hint(ValueHint::FilePath))
-      .arg(check_arg(true))
-      .arg(
+    .defer(|cmd| {
+      let cmd =
+      runtime_args(cmd, true, true)
+      .arg(check_arg(true));
+
+      let cmd = if *DENO_FUTURE {
+        cmd.arg(Arg::new("cmd").required_if_eq("global", "true").num_args(1..).value_hint(ValueHint::FilePath))
+      } else {
+        cmd.arg(Arg::new("cmd").required(true).num_args(1..).value_hint(ValueHint::FilePath))
+      };
+
+      cmd.arg(
         Arg::new("name")
           .long("name")
           .short('n')
           .help("Executable file name")
-          .required(false))
+          .required(false)
+      )
       .arg(
         Arg::new("root")
           .long("root")
           .help("Installation root")
-          .value_hint(ValueHint::DirPath))
+          .value_hint(ValueHint::DirPath)
+      )
       .arg(
         Arg::new("force")
           .long("force")
           .short('f')
           .help("Forcefully overwrite existing installation")
-          .action(ArgAction::SetTrue))
+          .action(ArgAction::SetTrue)
       )
       .arg(
         Arg::new("global")
@@ -2030,6 +2049,7 @@ These must be added to the path manually if required.")
           .action(ArgAction::SetTrue)
       )
       .arg(env_file_arg())
+    })
 }
 
 fn jupyter_subcommand() -> Command {
@@ -3795,28 +3815,35 @@ fn info_parse(flags: &mut Flags, matches: &mut ArgMatches) {
 fn install_parse(flags: &mut Flags, matches: &mut ArgMatches) {
   runtime_args_parse(flags, matches, true, true);
 
-  let root = matches.remove_one::<String>("root");
-
-  let force = matches.get_flag("force");
   let global = matches.get_flag("global");
-  let name = matches.remove_one::<String>("name");
-  let mut cmd_values = matches.remove_many::<String>("cmd").unwrap();
-
-  let module_url = cmd_values.next().unwrap();
-  let args = cmd_values.collect();
-
-  flags.subcommand = DenoSubcommand::Install(InstallFlags {
-    // TODO(bartlomieju): remove once `deno install` supports both local and
-    // global installs
-    global,
-    kind: InstallKind::Global(InstallFlagsGlobal {
-      name,
-      module_url,
-      args,
-      root,
-      force,
-    }),
-  });
+  if global {
+    let root = matches.remove_one::<String>("root");
+    let force = matches.get_flag("force");
+    let name = matches.remove_one::<String>("name");
+    let mut cmd_values =
+      matches.remove_many::<String>("cmd").unwrap_or_default();
+
+    let module_url = cmd_values.next().unwrap();
+    let args = cmd_values.collect();
+
+    flags.subcommand = DenoSubcommand::Install(InstallFlags {
+      // TODO(bartlomieju): remove once `deno install` supports both local and
+      // global installs
+      global,
+      kind: InstallKind::Global(InstallFlagsGlobal {
+        name,
+        module_url,
+        args,
+        root,
+        force,
+      }),
+    });
+  } else {
+    flags.subcommand = DenoSubcommand::Install(InstallFlags {
+      global,
+      kind: InstallKind::Local,
+    })
+  }
 }
 
 fn jupyter_parse(flags: &mut Flags, matches: &mut ArgMatches) {

cli/args/mod.rs

@@ -720,7 +720,7 @@ pub struct CliOptions {
   maybe_node_modules_folder: Option<PathBuf>,
   maybe_vendor_folder: Option<PathBuf>,
   maybe_config_file: Option<ConfigFile>,
-  maybe_package_json: Option<PackageJson>,
+  pub maybe_package_json: Option<PackageJson>,
   maybe_lockfile: Option<Arc<Mutex<Lockfile>>>,
   overrides: CliOptionOverrides,
   maybe_workspace_config: Option<WorkspaceConfig>,

cli/factory.rs

@@ -408,7 +408,8 @@ impl CliFactory {
       .npm_resolver
       .get_or_try_init_async(async {
         let fs = self.fs();
-        create_cli_npm_resolver(if self.options.use_byonm() {
+        // For `deno install` we want to force the managed resolver so it can set up `node_modules/` directory.
+        create_cli_npm_resolver(if self.options.use_byonm() && !matches!(self.options.sub_command(), DenoSubcommand::Install(_)) {
           CliNpmResolverCreateOptions::Byonm(CliNpmResolverByonmCreateOptions {
             fs: fs.clone(),
             root_node_modules_dir: match self.options.node_modules_dir_path() {

cli/main.rs

@@ -20,6 +20,7 @@ mod npm;
 mod ops;
 mod resolver;
 mod standalone;
+mod task_runner;
 mod tools;
 mod tsc;
 mod util;

cli/mainrt.rs

@@ -18,6 +18,7 @@ mod js;
 mod node;
 mod npm;
 mod resolver;
+mod task_runner;
 mod util;
 mod version;
 mod worker;

cli/npm/managed/resolvers/common.rs

@@ -23,7 +23,7 @@ use deno_runtime::deno_node::NodeResolutionMode;
 use super::super::cache::NpmCache;
 
 /// Part of the resolution that interacts with the file system.
-#[async_trait]
+#[async_trait(?Send)]
 pub trait NpmPackageFsResolver: Send + Sync {
   /// Specifier for the root directory.
   fn root_dir_url(&self) -> &Url;

cli/npm/managed/resolvers/global.rs

@@ -69,7 +69,7 @@ impl GlobalNpmPackageResolver {
   }
 }
 
-#[async_trait]
+#[async_trait(?Send)]
 impl NpmPackageFsResolver for GlobalNpmPackageResolver {
   fn root_dir_url(&self) -> &Url {
     self.cache.root_dir_url()