feat(install): more informative deno install output

Cargo.toml

@@ -63,22 +63,22 @@ repository = "https://github.com/denoland/deno"
 deno_ast = { version = "=0.49", features = ["transpiling"] }
 deno_core = { version = "0.355.0" }
 
-deno_cache_dir = "=0.24.0"
-deno_doc = "=0.181.0"
+deno_cache_dir = "=0.25.0"
+deno_doc = "=0.182.0"
 deno_error = "=0.7.0"
-deno_graph = { version = "=0.98.1", default-features = false }
+deno_graph = { version = "=0.99.0", default-features = false }
 deno_lint = "=0.77.0"
 deno_lockfile = "=0.31.2"
 deno_media_type = { version = "=0.2.9", features = ["module_specifier"] }
 deno_native_certs = "0.3.0"
-deno_npm = "=0.36.0"
+deno_npm = "=0.37.0"
 deno_path_util = "=0.6.1"
 deno_semver = "=0.9.0"
 deno_task_shell = "=0.26.0"
 deno_terminal = "=0.2.2"
 deno_unsync = { version = "0.4.4", default-features = false }
 deno_whoami = "0.1.0"
-eszip = "=0.95.0"
+eszip = "=0.96.0"
 
 denokv_proto = "0.12.0"
 denokv_remote = "0.12.0"

cli/factory.rs

@@ -303,7 +303,7 @@ struct CliFactoryServices {
   fs: Deferred<Arc<dyn deno_fs::FileSystem>>,
   http_client_provider: Deferred<Arc<HttpClientProvider>>,
   main_graph_container: Deferred<Arc<MainModuleGraphContainer>>,
-  maybe_file_watcher_reporter: Deferred<Option<FileWatcherReporter>>,
+  graph_reporter: Deferred<Option<Arc<dyn deno_graph::source::Reporter>>>,
   maybe_inspector_server: Deferred<Option<Arc<InspectorServer>>>,
   memory_files: Arc<MemoryFiles>,
   module_graph_builder: Deferred<Arc<ModuleGraphBuilder>>,
@@ -319,6 +319,8 @@ struct CliFactoryServices {
   text_only_progress_bar: Deferred<ProgressBar>,
   type_checker: Deferred<Arc<TypeChecker>>,
   workspace_factory: Deferred<Arc<CliWorkspaceFactory>>,
+  install_reporter:
+    Deferred<Option<Arc<crate::tools::installer::InstallReporter>>>,
 }
 
 #[derive(Debug, Default)]
@@ -568,6 +570,10 @@ impl CliFactory {
           None => Arc::new(NullLifecycleScriptsExecutor),
         },
         self.text_only_progress_bar().clone(),
+        self
+          .install_reporter()?
+          .cloned()
+          .map(|r| r as Arc<dyn deno_npm_installer::InstallReporter>),
         NpmInstallerFactoryOptions {
           cache_setting: NpmCacheSetting::from_cache_setting(
             &cli_options.cache_setting(),
@@ -582,6 +588,22 @@ impl CliFactory {
     })
   }
 
+  pub fn install_reporter(
+    &self,
+  ) -> Result<Option<&Arc<crate::tools::installer::InstallReporter>>, AnyError>
+  {
+    self
+      .services
+      .install_reporter
+      .get_or_try_init(|| match self.cli_options()?.sub_command() {
+        DenoSubcommand::Install(InstallFlags::Local(_)) => Ok(Some(Arc::new(
+          crate::tools::installer::InstallReporter::new(),
+        ))),
+        _ => Ok(None),
+      })
+      .map(|opt| opt.as_ref())
+  }
+
   pub async fn npm_installer(&self) -> Result<&Arc<CliNpmInstaller>, AnyError> {
     self.npm_installer_factory()?.npm_installer().await
   }
@@ -622,15 +644,25 @@ impl CliFactory {
     self.resolver_factory()?.deno_resolver().await
   }
 
-  pub fn maybe_file_watcher_reporter(&self) -> &Option<FileWatcherReporter> {
-    let maybe_file_watcher_reporter = self
-      .watcher_communicator
-      .as_ref()
-      .map(|i| FileWatcherReporter::new(i.clone()));
-    self
-      .services
-      .maybe_file_watcher_reporter
-      .get_or_init(|| maybe_file_watcher_reporter)
+  pub fn graph_reporter(
+    &self,
+  ) -> Result<&Option<Arc<dyn deno_graph::source::Reporter>>, AnyError> {
+    match self.cli_options()?.sub_command() {
+      DenoSubcommand::Install(_) => {
+        self.services.graph_reporter.get_or_try_init(|| {
+          self.install_reporter().map(|opt| {
+            opt.map(|r| r.clone() as Arc<dyn deno_graph::source::Reporter>)
+          })
+        })
+      }
+      _ => Ok(self.services.graph_reporter.get_or_init(|| {
+        self
+          .watcher_communicator
+          .as_ref()
+          .map(|i| FileWatcherReporter::new(i.clone()))
+          .map(|i| Arc::new(i) as Arc<dyn deno_graph::source::Reporter>)
+      })),
+    }
   }
 
   pub fn module_info_cache(&self) -> Result<&Arc<ModuleInfoCache>, AnyError> {
@@ -737,7 +769,7 @@ impl CliFactory {
             self.global_http_cache()?.clone(),
             self.in_npm_pkg_checker()?.clone(),
             self.maybe_lockfile().await?.cloned(),
-            self.maybe_file_watcher_reporter().clone(),
+            self.graph_reporter()?.clone(),
             self.module_info_cache()?.clone(),
             self.npm_graph_resolver().await?.clone(),
             self.npm_installer_if_managed().await?.cloned(),
@@ -748,6 +780,9 @@ impl CliFactory {
             self.root_permissions_container()?.clone(),
             self.sys(),
             self.compiler_options_resolver()?.clone(),
+            self.install_reporter()?.cloned().map(|r| {
+              r as Arc<dyn deno_resolver::file_fetcher::GraphLoaderReporter>
+            }),
           )))
         }
         .boxed_local(),

cli/file_fetcher.rs

@@ -397,6 +397,7 @@ mod tests {
         "content-type".to_string(),
         "application/javascript".to_string(),
       )])),
+      loaded_from: deno_cache_dir::file_fetcher::LoadedFrom::Local,
     };
     file_fetcher.insert_memory_files(file.clone());
 

cli/graph_util.rs

@@ -34,6 +34,7 @@ use deno_resolver::cache::ParsedSourceCache;
 use deno_resolver::deno_json::CompilerOptionsResolver;
 use deno_resolver::deno_json::JsxImportSourceConfigResolver;
 use deno_resolver::deno_json::ToMaybeJsxImportSourceConfigError;
+use deno_resolver::file_fetcher::GraphLoaderReporterRc;
 use deno_resolver::graph::EnhanceGraphErrorMode;
 use deno_resolver::graph::enhance_graph_error;
 use deno_resolver::graph::enhanced_integrity_error_message;
@@ -604,7 +605,7 @@ pub struct ModuleGraphBuilder {
   global_http_cache: Arc<GlobalHttpCache>,
   in_npm_pkg_checker: DenoInNpmPackageChecker,
   lockfile: Option<Arc<CliLockfile>>,
-  maybe_file_watcher_reporter: Option<FileWatcherReporter>,
+  maybe_reporter: Option<Arc<dyn deno_graph::source::Reporter>>,
   module_info_cache: Arc<ModuleInfoCache>,
   npm_graph_resolver: Arc<CliNpmGraphResolver>,
   npm_installer: Option<Arc<CliNpmInstaller>>,
@@ -615,6 +616,7 @@ pub struct ModuleGraphBuilder {
   root_permissions_container: PermissionsContainer,
   sys: CliSys,
   compiler_options_resolver: Arc<CompilerOptionsResolver>,
+  load_reporter: Option<GraphLoaderReporterRc>,
 }
 
 impl ModuleGraphBuilder {
@@ -627,7 +629,7 @@ impl ModuleGraphBuilder {
     global_http_cache: Arc<GlobalHttpCache>,
     in_npm_pkg_checker: DenoInNpmPackageChecker,
     lockfile: Option<Arc<CliLockfile>>,
-    maybe_file_watcher_reporter: Option<FileWatcherReporter>,
+    maybe_reporter: Option<Arc<dyn deno_graph::source::Reporter>>,
     module_info_cache: Arc<ModuleInfoCache>,
     npm_graph_resolver: Arc<CliNpmGraphResolver>,
     npm_installer: Option<Arc<CliNpmInstaller>>,
@@ -638,6 +640,7 @@ impl ModuleGraphBuilder {
     root_permissions_container: PermissionsContainer,
     sys: CliSys,
     compiler_options_resolver: Arc<CompilerOptionsResolver>,
+    load_reporter: Option<GraphLoaderReporterRc>,
   ) -> Self {
     Self {
       caches,
@@ -647,7 +650,7 @@ impl ModuleGraphBuilder {
       global_http_cache,
       in_npm_pkg_checker,
       lockfile,
-      maybe_file_watcher_reporter,
+      maybe_reporter,
       module_info_cache,
       npm_graph_resolver,
       npm_installer,
@@ -658,6 +661,7 @@ impl ModuleGraphBuilder {
       root_permissions_container,
       sys,
       compiler_options_resolver,
+      load_reporter,
     }
   }
 
@@ -696,10 +700,7 @@ impl ModuleGraphBuilder {
       self.cjs_tracker.as_ref(),
       &jsx_import_source_config_resolver,
     );
-    let maybe_file_watcher_reporter = self
-      .maybe_file_watcher_reporter
-      .as_ref()
-      .map(|r| r.as_reporter());
+    let maybe_reporter = self.maybe_reporter.as_deref();
     let mut locker = self.lockfile.as_ref().map(|l| l.as_deno_graph_locker());
     self
       .build_graph_with_npm_resolution_and_build_options(
@@ -717,7 +718,7 @@ impl ModuleGraphBuilder {
           npm_resolver: Some(self.npm_graph_resolver.as_ref()),
           module_analyzer: &analyzer,
           module_info_cacher: self.module_info_cache.as_ref(),
-          reporter: maybe_file_watcher_reporter,
+          reporter: maybe_reporter,
           resolver: Some(&graph_resolver),
           locker: locker.as_mut().map(|l| l as _),
           unstable_bytes_imports: self.cli_options.unstable_raw_imports(),
@@ -926,6 +927,7 @@ impl ModuleGraphBuilder {
       deno_resolver::file_fetcher::DenoGraphLoaderOptions {
         file_header_overrides: self.cli_options.resolve_file_header_overrides(),
         permissions: Some(permissions),
+        reporter: self.load_reporter.clone(),
       },
     )
   }
@@ -1014,10 +1016,6 @@ impl FileWatcherReporter {
       file_paths: Default::default(),
     }
   }
-
-  pub fn as_reporter(&self) -> &dyn deno_graph::source::Reporter {
-    self
-  }
 }
 
 impl deno_graph::source::Reporter for FileWatcherReporter {

cli/lsp/config.rs

@@ -1480,6 +1480,7 @@ impl ConfigData {
       )),
       Arc::new(NullLifecycleScriptsExecutor),
       pb,
+      None,
       NpmInstallerFactoryOptions {
         cache_setting: NpmCacheSetting::Use,
         caching_strategy: NpmCachingStrategy::Eager,