fix(upgrade): do not error if config in cwd invalid (#24689)

```
> deno upgrade
error: Unsupported lockfile version 'invalid'. Try upgrading Deno or recreating the lockfile.
V:\scratch
> V:\deno\target\debug\deno upgrade
Looking up latest version
Local deno version 1.45.3 is the most recent release
```

Closes #24517
Closes #20729

1 files changed, 173 insertions, 222 deletions

diff --git a/cli/factory.rs b/cli/factory.rs
index 18757cda6..d701c2719 100644
--- a/cli/factory.rs
+++ b/cli/factory.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-use crate::args::CliLockfile;
+use crate::args::get_root_cert_store;
+use crate::args::CaData;
 use crate::args::CliOptions;
 use crate::args::DenoSubcommand;
 use crate::args::Flags;
@@ -51,59 +52,60 @@ use crate::util::progress_bar::ProgressBar;
 use crate::util::progress_bar::ProgressBarStyle;
 use crate::worker::CliMainWorkerFactory;
 use crate::worker::CliMainWorkerOptions;
-use std::collections::BTreeSet;
 use std::path::PathBuf;
 
-use deno_config::deno_json::ConfigFile;
 use deno_config::workspace::PackageJsonDepResolution;
 use deno_config::workspace::WorkspaceResolver;
 use deno_core::error::AnyError;
 use deno_core::futures::FutureExt;
 use deno_core::FeatureChecker;
-use deno_package_json::PackageJsonDepValue;
 
-use deno_lockfile::WorkspaceMemberConfig;
 use deno_runtime::deno_fs;
 use deno_runtime::deno_node::analyze::NodeCodeTranslator;
 use deno_runtime::deno_node::NodeResolver;
-use deno_runtime::deno_node::PackageJson;
+use deno_runtime::deno_tls::rustls::RootCertStore;
 use deno_runtime::deno_tls::RootCertStoreProvider;
 use deno_runtime::deno_web::BlobStore;
 use deno_runtime::inspector_server::InspectorServer;
 use log::warn;
+use once_cell::sync::OnceCell;
 use std::future::Future;
 use std::sync::Arc;
 
-pub struct CliFactoryBuilder {
-  watcher_communicator: Option<Arc<WatcherCommunicator>>,
+struct CliRootCertStoreProvider {
+  cell: OnceCell<RootCertStore>,
+  maybe_root_path: Option<PathBuf>,
+  maybe_ca_stores: Option<Vec<String>>,
+  maybe_ca_data: Option<CaData>,
 }
 
-impl CliFactoryBuilder {
-  pub fn new() -> Self {
+impl CliRootCertStoreProvider {
+  pub fn new(
+    maybe_root_path: Option<PathBuf>,
+    maybe_ca_stores: Option<Vec<String>>,
+    maybe_ca_data: Option<CaData>,
+  ) -> Self {
     Self {
-      watcher_communicator: None,
+      cell: Default::default(),
+      maybe_root_path,
+      maybe_ca_stores,
+      maybe_ca_data,
     }
   }
+}
 
-  pub fn build_from_flags(self, flags: Flags) -> Result<CliFactory, AnyError> {
-    Ok(self.build_from_cli_options(Arc::new(CliOptions::from_flags(flags)?)))
-  }
-
-  pub fn build_from_flags_for_watcher(
-    mut self,
-    flags: Flags,
-    watcher_communicator: Arc<WatcherCommunicator>,
-  ) -> Result<CliFactory, AnyError> {
-    self.watcher_communicator = Some(watcher_communicator);
-    self.build_from_flags(flags)
-  }
-
-  pub fn build_from_cli_options(self, options: Arc<CliOptions>) -> CliFactory {
-    CliFactory {
-      watcher_communicator: self.watcher_communicator,
-      options,
-      services: Default::default(),
-    }
+impl RootCertStoreProvider for CliRootCertStoreProvider {
+  fn get_or_try_init(&self) -> Result<&RootCertStore, AnyError> {
+    self
+      .cell
+      .get_or_try_init(|| {
+        get_root_cert_store(
+          self.maybe_root_path.clone(),
+          self.maybe_ca_stores.clone(),
+          self.maybe_ca_data.clone(),
+        )
+      })
+      .map_err(|e| e.into())
   }
 }
 
@@ -116,6 +118,10 @@ impl<T> Default for Deferred<T> {
 }
 
 impl<T> Deferred<T> {
+  pub fn from_value(value: T) -> Self {
+    Self(once_cell::unsync::OnceCell::from(value))
+  }
+
   #[inline(always)]
   pub fn get_or_try_init(
     &self,
@@ -149,6 +155,7 @@ impl<T> Deferred<T> {
 
 #[derive(Default)]
 struct CliFactoryServices {
+  cli_options: Deferred<Arc<CliOptions>>,
   deno_dir_provider: Deferred<Arc<DenoDirProvider>>,
   caches: Deferred<Arc<Caches>>,
   file_fetcher: Deferred<Arc<FileFetcher>>,
@@ -159,7 +166,6 @@ struct CliFactoryServices {
   emitter: Deferred<Arc<Emitter>>,
   fs: Deferred<Arc<dyn deno_fs::FileSystem>>,
   main_graph_container: Deferred<Arc<MainModuleGraphContainer>>,
-  lockfile: Deferred<Option<Arc<CliLockfile>>>,
   maybe_inspector_server: Deferred<Option<Arc<InspectorServer>>>,
   root_cert_store_provider: Deferred<Arc<dyn RootCertStoreProvider>>,
   blob_store: Deferred<Arc<BlobStore>>,
@@ -184,40 +190,66 @@ struct CliFactoryServices {
 
 pub struct CliFactory {
   watcher_communicator: Option<Arc<WatcherCommunicator>>,
-  options: Arc<CliOptions>,
+  flags: Arc<Flags>,
   services: CliFactoryServices,
 }
 
 impl CliFactory {
-  pub fn from_flags(flags: Flags) -> Result<Self, AnyError> {
-    CliFactoryBuilder::new().build_from_flags(flags)
+  pub fn from_flags(flags: Arc<Flags>) -> Self {
+    Self {
+      flags,
+      watcher_communicator: None,
+      services: Default::default(),
+    }
+  }
+
+  pub fn from_cli_options(cli_options: Arc<CliOptions>) -> Self {
+    let (cli_options, flags) = cli_options.into_self_and_flags();
+    CliFactory {
+      watcher_communicator: None,
+      flags,
+      services: CliFactoryServices {
+        cli_options: Deferred::from_value(cli_options),
+        ..Default::default()
+      },
+    }
   }
 
-  pub fn from_cli_options(options: Arc<CliOptions>) -> Self {
-    CliFactoryBuilder::new().build_from_cli_options(options)
+  pub fn from_flags_for_watcher(
+    flags: Arc<Flags>,
+    watcher_communicator: Arc<WatcherCommunicator>,
+  ) -> Self {
+    CliFactory {
+      watcher_communicator: Some(watcher_communicator),
+      flags,
+      services: Default::default(),
+    }
   }
 
-  pub fn cli_options(&self) -> &Arc<CliOptions> {
-    &self.options
+  pub fn cli_options(&self) -> Result<&Arc<CliOptions>, AnyError> {
+    self.services.cli_options.get_or_try_init(|| {
+      CliOptions::from_flags(self.flags.clone()).map(Arc::new)
+    })
   }
 
-  pub fn deno_dir_provider(&self) -> &Arc<DenoDirProvider> {
-    self.services.deno_dir_provider.get_or_init(|| {
-      Arc::new(DenoDirProvider::new(
-        self.options.maybe_custom_root().clone(),
-      ))
+  pub fn deno_dir_provider(&self) -> Result<&Arc<DenoDirProvider>, AnyError> {
+    self.services.deno_dir_provider.get_or_try_init(|| {
+      Ok(Arc::new(DenoDirProvider::new(
+        self.cli_options()?.maybe_custom_root().clone(),
+      )))
     })
   }
 
   pub fn deno_dir(&self) -> Result<&DenoDir, AnyError> {
-    Ok(self.deno_dir_provider().get_or_create()?)
+    Ok(self.deno_dir_provider()?.get_or_create()?)
   }
 
   pub fn caches(&self) -> Result<&Arc<Caches>, AnyError> {
     self.services.caches.get_or_try_init(|| {
-      let caches = Arc::new(Caches::new(self.deno_dir_provider().clone()));
+      let cli_options = self.cli_options()?;
+      let caches = Arc::new(Caches::new(self.deno_dir_provider()?.clone()));
       // Warm up the caches we know we'll likely need based on the CLI mode
-      match self.options.sub_command() {
+      match cli_options.sub_command() {
         DenoSubcommand::Run(_)
         | DenoSubcommand::Serve(_)
         | DenoSubcommand::Bench(_)
@@ -225,11 +257,11 @@ impl CliFactory {
         | DenoSubcommand::Check(_) => {
           _ = caches.dep_analysis_db();
           _ = caches.node_analysis_db();
-          if self.options.type_check_mode().is_true() {
+          if cli_options.type_check_mode().is_true() {
             _ = caches.fast_check_db();
             _ = caches.type_checking_cache_db();
           }
-          if self.options.code_cache_enabled() {
+          if cli_options.code_cache_enabled() {
             _ = caches.code_cache_db();
           }
         }
@@ -244,10 +276,13 @@ impl CliFactory {
   }
 
   pub fn root_cert_store_provider(&self) -> &Arc<dyn RootCertStoreProvider> {
-    self
-      .services
-      .root_cert_store_provider
-      .get_or_init(|| self.options.resolve_root_cert_store_provider())
+    self.services.root_cert_store_provider.get_or_init(|| {
+      Arc::new(CliRootCertStoreProvider::new(
+        None,
+        self.flags.ca_stores.clone(),
+        self.flags.ca_data.clone(),
+      ))
+    })
   }
 
   pub fn text_only_progress_bar(&self) -> &ProgressBar {
@@ -269,7 +304,7 @@ impl CliFactory {
   pub fn http_cache(&self) -> Result<&Arc<dyn HttpCache>, AnyError> {
     self.services.http_cache.get_or_try_init(|| {
       let global_cache = self.global_http_cache()?.clone();
-      match self.options.vendor_dir_path() {
+      match self.cli_options()?.vendor_dir_path() {
         Some(local_path) => {
           let local_cache =
             LocalHttpCache::new(local_path.clone(), global_cache);
@@ -284,17 +319,18 @@ impl CliFactory {
     self.services.http_client_provider.get_or_init(|| {
       Arc::new(HttpClientProvider::new(
         Some(self.root_cert_store_provider().clone()),
-        self.options.unsafely_ignore_certificate_errors().clone(),
+        self.flags.unsafely_ignore_certificate_errors.clone(),
       ))
     })
   }
 
   pub fn file_fetcher(&self) -> Result<&Arc<FileFetcher>, AnyError> {
     self.services.file_fetcher.get_or_try_init(|| {
+      let cli_options = self.cli_options()?;
       Ok(Arc::new(FileFetcher::new(
         self.http_cache()?.clone(),
-        self.options.cache_setting(),
-        !self.options.no_remote(),
+        cli_options.cache_setting(),
+        !cli_options.no_remote(),
         self.http_client_provider().clone(),
         self.blob_store().clone(),
         Some(self.text_only_progress_bar().clone()),
@@ -306,98 +342,6 @@ impl CliFactory {
     self.services.fs.get_or_init(|| Arc::new(deno_fs::RealFs))
   }
 
-  pub fn maybe_lockfile(&self) -> &Option<Arc<CliLockfile>> {
-    fn pkg_json_deps(maybe_pkg_json: Option<&PackageJson>) -> BTreeSet<String> {
-      let Some(pkg_json) = maybe_pkg_json else {
-        return Default::default();
-      };
-      pkg_json
-        .resolve_local_package_json_deps()
-        .values()
-        .filter_map(|dep| dep.as_ref().ok())
-        .filter_map(|dep| match dep {
-          PackageJsonDepValue::Req(req) => Some(req),
-          PackageJsonDepValue::Workspace(_) => None,
-        })
-        .map(|r| format!("npm:{}", r))
-        .collect()
-    }
-
-    fn deno_json_deps(
-      maybe_deno_json: Option<&ConfigFile>,
-    ) -> BTreeSet<String> {
-      maybe_deno_json
-        .map(|c| {
-          crate::args::deno_json::deno_json_deps(c)
-            .into_iter()
-            .map(|req| req.to_string())
-            .collect()
-        })
-        .unwrap_or_default()
-    }
-
-    self.services.lockfile.get_or_init(|| {
-      let maybe_lockfile = self.options.maybe_lockfile();
-
-      // initialize the lockfile with the workspace's configuration
-      if let Some(lockfile) = &maybe_lockfile {
-        let root_url = self.options.workspace().root_dir();
-        let root_folder = self.options.workspace().root_folder_configs();
-        let config = deno_lockfile::WorkspaceConfig {
-          root: WorkspaceMemberConfig {
-            package_json_deps: pkg_json_deps(root_folder.pkg_json.as_deref()),
-            dependencies: deno_json_deps(root_folder.deno_json.as_deref()),
-          },
-          members: self
-            .options
-            .workspace()
-            .config_folders()
-            .iter()
-            .filter(|(folder_url, _)| *folder_url != root_url)
-            .filter_map(|(folder_url, folder)| {
-              Some((
-                {
-                  // should never be None here, but just ignore members that
-                  // do fail for this
-                  let mut relative_path = root_url.make_relative(folder_url)?;
-                  if relative_path.ends_with('/') {
-                    // make it slightly cleaner by removing the trailing slash
-                    relative_path.pop();
-                  }
-                  relative_path
-                },
-                {
-                  let config = WorkspaceMemberConfig {
-                    package_json_deps: pkg_json_deps(
-                      folder.pkg_json.as_deref(),
-                    ),
-                    dependencies: deno_json_deps(folder.deno_json.as_deref()),
-                  };
-                  if config.package_json_deps.is_empty()
-                    && config.dependencies.is_empty()
-                  {
-                    // exclude empty workspace members
-                    return None;
-                  }
-                  config
-                },
-              ))
-            })
-            .collect(),
-        };
-        lockfile.set_workspace_config(
-          deno_lockfile::SetWorkspaceConfigOptions {
-            no_npm: self.options.no_npm(),
-            no_config: self.options.no_config(),
-            config,
-          },
-        );
-      }
-
-      maybe_lockfile
-    })
-  }
-
   pub async fn npm_resolver(
     &self,
   ) -> Result<&Arc<dyn CliNpmResolver>, AnyError> {
@@ -406,25 +350,26 @@ impl CliFactory {
       .npm_resolver
       .get_or_try_init_async(async {
         let fs = self.fs();
+        let cli_options = self.cli_options()?;
         // 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(_)) {
+        create_cli_npm_resolver(if cli_options.use_byonm() && !matches!(cli_options.sub_command(), DenoSubcommand::Install(_)) {
           CliNpmResolverCreateOptions::Byonm(CliNpmResolverByonmCreateOptions {
             fs: fs.clone(),
-            root_node_modules_dir: Some(match self.options.node_modules_dir_path() {
+            root_node_modules_dir: Some(match cli_options.node_modules_dir_path() {
               Some(node_modules_path) => node_modules_path.to_path_buf(),
               // path needs to be canonicalized for node resolution
               // (node_modules_dir_path above is already canonicalized)
-              None => canonicalize_path_maybe_not_exists(self.options.initial_cwd())?
+              None => canonicalize_path_maybe_not_exists(cli_options.initial_cwd())?
                 .join("node_modules"),
             }),
           })
         } else {
           CliNpmResolverCreateOptions::Managed(CliNpmResolverManagedCreateOptions {
-            snapshot: match self.options.resolve_npm_resolution_snapshot()? {
+            snapshot: match cli_options.resolve_npm_resolution_snapshot()? {
               Some(snapshot) => {
                 CliNpmResolverManagedSnapshotOption::Specified(Some(snapshot))
               }
-              None => match self.maybe_lockfile().as_ref() {
+              None => match cli_options.maybe_lockfile() {
                 Some(lockfile) => {
                   CliNpmResolverManagedSnapshotOption::ResolveFromLockfile(
                     lockfile.clone(),
@@ -433,19 +378,19 @@ impl CliFactory {
                 None => CliNpmResolverManagedSnapshotOption::Specified(None),
               },
             },
-            maybe_lockfile: self.maybe_lockfile().as_ref().cloned(),
+            maybe_lockfile: cli_options.maybe_lockfile().cloned(),
             fs: fs.clone(),
             http_client_provider: self.http_client_provider().clone(),
             npm_global_cache_dir: self.deno_dir()?.npm_folder_path(),
-            cache_setting: self.options.cache_setting(),
+            cache_setting: cli_options.cache_setting(),
             text_only_progress_bar: self.text_only_progress_bar().clone(),
-            maybe_node_modules_path: self.options.node_modules_dir_path().cloned(),
+            maybe_node_modules_path: cli_options.node_modules_dir_path().cloned(),
             package_json_deps_provider: Arc::new(PackageJsonInstallDepsProvider::from_workspace(
-              self.options.workspace(),
+              cli_options.workspace(),
             )),
-            npm_system_info: self.options.npm_system_info(),
-            npmrc: self.options.npmrc().clone(),
-            lifecycle_scripts: self.options.lifecycle_scripts_config(),
+            npm_system_info: cli_options.npm_system_info(),
+            npmrc: cli_options.npmrc().clone(),
+            lifecycle_scripts: cli_options.lifecycle_scripts_config(),
           })
         }).await
       }.boxed_local())
@@ -459,11 +404,11 @@ impl CliFactory {
       .services
       .workspace_resolver
       .get_or_try_init_async(async {
-        let resolver = self
-          .options
+        let cli_options = self.cli_options()?;
+        let resolver = cli_options
           .create_workspace_resolver(
             self.file_fetcher()?,
-            if self.options.use_byonm() {
+            if cli_options.use_byonm() {
               PackageJsonDepResolution::Disabled
             } else {
               // todo(dsherret): this should be false for nodeModulesDir: true
@@ -493,27 +438,26 @@ impl CliFactory {
       .resolver
       .get_or_try_init_async(
         async {
+          let cli_options = self.cli_options()?;
           Ok(Arc::new(CliGraphResolver::new(CliGraphResolverOptions {
-            sloppy_imports_resolver: if self.options.unstable_sloppy_imports() {
+            sloppy_imports_resolver: if cli_options.unstable_sloppy_imports() {
               Some(SloppyImportsResolver::new(self.fs().clone()))
             } else {
               None
             },
             node_resolver: Some(self.cli_node_resolver().await?.clone()),
-            npm_resolver: if self.options.no_npm() {
+            npm_resolver: if cli_options.no_npm() {
               None
             } else {
               Some(self.npm_resolver().await?.clone())
             },
             workspace_resolver: self.workspace_resolver().await?.clone(),
-            bare_node_builtins_enabled: self
-              .options
+            bare_node_builtins_enabled: cli_options
               .unstable_bare_node_builtins(),
-            maybe_jsx_import_source_config: self
-              .options
+            maybe_jsx_import_source_config: cli_options
               .workspace()
               .to_maybe_jsx_import_source_config()?,
-            maybe_vendor_dir: self.options.vendor_dir_path(),
+            maybe_vendor_dir: cli_options.vendor_dir_path(),
           })))
         }
         .boxed_local(),
@@ -561,9 +505,9 @@ impl CliFactory {
 
   pub fn emitter(&self) -> Result<&Arc<Emitter>, AnyError> {
     self.services.emitter.get_or_try_init(|| {
-      let ts_config_result = self
-        .options
-        .resolve_ts_config_for_emit(TsConfigType::Emit)?;
+      let cli_options = self.cli_options()?;
+      let ts_config_result =
+        cli_options.resolve_ts_config_for_emit(TsConfigType::Emit)?;
       if let Some(ignored_options) = ts_config_result.maybe_ignored_options {
         warn!("{}", ignored_options);
       }
@@ -624,9 +568,10 @@ impl CliFactory {
       .services
       .type_checker
       .get_or_try_init_async(async {
+        let cli_options = self.cli_options()?;
         Ok(Arc::new(TypeChecker::new(
           self.caches()?.clone(),
-          self.options.clone(),
+          cli_options.clone(),
           self.module_graph_builder().await?.clone(),
           self.node_resolver().await?.clone(),
           self.npm_resolver().await?.clone(),
@@ -642,15 +587,16 @@ impl CliFactory {
       .services
       .module_graph_builder
       .get_or_try_init_async(async {
+        let cli_options = self.cli_options()?;
         Ok(Arc::new(ModuleGraphBuilder::new(
-          self.options.clone(),
+          cli_options.clone(),
           self.caches()?.clone(),
           self.fs().clone(),
           self.resolver().await?.clone(),
           self.npm_resolver().await?.clone(),
           self.module_info_cache()?.clone(),
           self.parsed_source_cache().clone(),
-          self.maybe_lockfile().clone(),
+          cli_options.maybe_lockfile().cloned(),
           self.maybe_file_watcher_reporter().clone(),
           self.emit_cache()?.clone(),
           self.file_fetcher()?.clone(),
@@ -667,8 +613,9 @@ impl CliFactory {
       .services
       .module_graph_creator
       .get_or_try_init_async(async {
+        let cli_options = self.cli_options()?;
         Ok(Arc::new(ModuleGraphCreator::new(
-          self.options.clone(),
+          cli_options.clone(),
           self.npm_resolver().await?.clone(),
           self.module_graph_builder().await?.clone(),
           self.type_checker().await?.clone(),
@@ -685,7 +632,7 @@ impl CliFactory {
       .main_graph_container
       .get_or_try_init_async(async {
         Ok(Arc::new(MainModuleGraphContainer::new(
-          self.cli_options().clone(),
+          self.cli_options()?.clone(),
           self.module_load_preparer().await?.clone(),
         )))
       })
@@ -696,7 +643,8 @@ impl CliFactory {
     &self,
   ) -> Result<&Option<Arc<InspectorServer>>, AnyError> {
     self.services.maybe_inspector_server.get_or_try_init(|| {
-      match self.options.resolve_inspector_server() {
+      let cli_options = self.cli_options()?;
+      match cli_options.resolve_inspector_server() {
         Ok(server) => Ok(server.map(Arc::new)),
         Err(err) => Err(err),
       }
@@ -710,9 +658,10 @@ impl CliFactory {
       .services
       .module_load_preparer
       .get_or_try_init_async(async {
+        let cli_options = self.cli_options()?;
         Ok(Arc::new(ModuleLoadPreparer::new(
-          self.options.clone(),
-          self.maybe_lockfile().clone(),
+          cli_options.clone(),
+          cli_options.maybe_lockfile().cloned(),
           self.module_graph_builder().await?.clone(),
           self.text_only_progress_bar().clone(),
           self.type_checker().await?.clone(),
@@ -742,61 +691,64 @@ impl CliFactory {
       .await
   }
 
-  pub fn feature_checker(&self) -> &Arc<FeatureChecker> {
-    self.services.feature_checker.get_or_init(|| {
+  pub fn feature_checker(&self) -> Result<&Arc<FeatureChecker>, AnyError> {
+    self.services.feature_checker.get_or_try_init(|| {
+      let cli_options = self.cli_options()?;
       let mut checker = FeatureChecker::default();
       checker.set_exit_cb(Box::new(crate::unstable_exit_cb));
       checker.set_warn_cb(Box::new(crate::unstable_warn_cb));
-      if self.options.legacy_unstable_flag() {
+      if cli_options.legacy_unstable_flag() {
         checker.enable_legacy_unstable();
         checker.warn_on_legacy_unstable();
       }
-      let unstable_features = self.options.unstable_features();
+      let unstable_features = cli_options.unstable_features();
       for (flag_name, _, _) in crate::UNSTABLE_GRANULAR_FLAGS {
         if unstable_features.contains(&flag_name.to_string()) {
           checker.enable_feature(flag_name);
         }
       }
 
-      Arc::new(checker)
+      Ok(Arc::new(checker))
     })
   }
 
   pub async fn create_compile_binary_writer(
     &self,
   ) -> Result<DenoCompileBinaryWriter, AnyError> {
+    let cli_options = self.cli_options()?;
     Ok(DenoCompileBinaryWriter::new(
       self.deno_dir()?,
       self.file_fetcher()?,
       self.http_client_provider(),
       self.npm_resolver().await?.as_ref(),
       self.workspace_resolver().await?.as_ref(),
-      self.options.npm_system_info(),
+      cli_options.npm_system_info(),
     ))
   }
 
   pub async fn create_cli_main_worker_factory(
     &self,
   ) -> Result<CliMainWorkerFactory, AnyError> {
+    let cli_options = self.cli_options()?;
     let node_resolver = self.node_resolver().await?;
     let npm_resolver = self.npm_resolver().await?;
     let fs = self.fs();
     let cli_node_resolver = self.cli_node_resolver().await?;
-    let maybe_file_watcher_communicator = if self.options.has_hmr() {
+    let maybe_file_watcher_communicator = if cli_options.has_hmr() {
       Some(self.watcher_communicator.clone().unwrap())
     } else {
       None
     };
 
     Ok(CliMainWorkerFactory::new(
-      StorageKeyResolver::from_options(&self.options),
-      self.options.sub_command().clone(),
+      StorageKeyResolver::from_options(cli_options),
+      cli_options.sub_command().clone(),
       npm_resolver.clone(),
       node_resolver.clone(),
       self.blob_store().clone(),
       Box::new(CliModuleLoaderFactory::new(
-        &self.options,
-        if self.options.code_cache_enabled() {
+        cli_options,
+        if cli_options.code_cache_enabled() {
           Some(self.code_cache()?.clone())
         } else {
           None
@@ -818,18 +770,18 @@ impl CliFactory {
       self.fs().clone(),
       maybe_file_watcher_communicator,
       self.maybe_inspector_server()?.clone(),
-      self.maybe_lockfile().clone(),
-      self.feature_checker().clone(),
+      cli_options.maybe_lockfile().cloned(),
+      self.feature_checker()?.clone(),
       self.create_cli_main_worker_options()?,
-      self.options.node_ipc_fd(),
-      self.options.serve_port(),
-      self.options.serve_host(),
-      self.options.enable_future_features(),
+      cli_options.node_ipc_fd(),
+      cli_options.serve_port(),
+      cli_options.serve_host(),
+      cli_options.enable_future_features(),
       // TODO(bartlomieju): temporarily disabled
-      // self.options.disable_deprecated_api_warning,
+      // cli_options.disable_deprecated_api_warning,
       true,
-      self.options.verbose_deprecated_api_warning,
-      if self.options.code_cache_enabled() {
+      cli_options.verbose_deprecated_api_warning,
+      if cli_options.code_cache_enabled() {
         Some(self.code_cache()?.clone())
       } else {
         None
@@ -840,7 +792,8 @@ impl CliFactory {
   fn create_cli_main_worker_options(
     &self,
   ) -> Result<CliMainWorkerOptions, AnyError> {
-    let create_hmr_runner = if self.options.has_hmr() {
+    let cli_options = self.cli_options()?;
+    let create_hmr_runner = if cli_options.has_hmr() {
       let watcher_communicator = self.watcher_communicator.clone().unwrap();
       let emitter = self.emitter()?.clone();
       let fn_: crate::worker::CreateHmrRunnerCb = Box::new(move |session| {
@@ -855,7 +808,7 @@ impl CliFactory {
       None
     };
     let create_coverage_collector =
-      if let Some(coverage_dir) = self.options.coverage_dir() {
+      if let Some(coverage_dir) = cli_options.coverage_dir() {
         let coverage_dir = PathBuf::from(coverage_dir);
         let fn_: crate::worker::CreateCoverageCollectorCb =
           Box::new(move |session| {
@@ -867,36 +820,34 @@ impl CliFactory {
       };
 
     Ok(CliMainWorkerOptions {
-      argv: self.options.argv().clone(),
+      argv: cli_options.argv().clone(),
       // This optimization is only available for "run" subcommand
       // because we need to register new ops for testing and jupyter
       // integration.
-      skip_op_registration: self.options.sub_command().is_run(),
-      log_level: self.options.log_level().unwrap_or(log::Level::Info).into(),
-      enable_op_summary_metrics: self.options.enable_op_summary_metrics(),
-      enable_testing_features: self.options.enable_testing_features(),
-      has_node_modules_dir: self.options.has_node_modules_dir(),
-      hmr: self.options.has_hmr(),
-      inspect_brk: self.options.inspect_brk().is_some(),
-      inspect_wait: self.options.inspect_wait().is_some(),
-      strace_ops: self.options.strace_ops().clone(),
-      is_inspecting: self.options.is_inspecting(),
-      is_npm_main: self.options.is_npm_main(),
-      location: self.options.location_flag().clone(),
+      skip_op_registration: cli_options.sub_command().is_run(),
+      log_level: cli_options.log_level().unwrap_or(log::Level::Info).into(),
+      enable_op_summary_metrics: cli_options.enable_op_summary_metrics(),
+      enable_testing_features: cli_options.enable_testing_features(),
+      has_node_modules_dir: cli_options.has_node_modules_dir(),
+      hmr: cli_options.has_hmr(),
+      inspect_brk: cli_options.inspect_brk().is_some(),
+      inspect_wait: cli_options.inspect_wait().is_some(),
+      strace_ops: cli_options.strace_ops().clone(),
+      is_inspecting: cli_options.is_inspecting(),
+      is_npm_main: cli_options.is_npm_main(),
+      location: cli_options.location_flag().clone(),
       // if the user ran a binary command, we'll need to set process.argv[0]
       // to be the name of the binary command instead of deno
-      argv0: self
-        .options
+      argv0: cli_options
         .take_binary_npm_command_name()
         .or(std::env::args().next()),
       node_debug: std::env::var("NODE_DEBUG").ok(),
       origin_data_folder_path: Some(self.deno_dir()?.origin_data_folder_path()),
-      seed: self.options.seed(),
-      unsafely_ignore_certificate_errors: self
-        .options
+      seed: cli_options.seed(),
+      unsafely_ignore_certificate_errors: cli_options
         .unsafely_ignore_certificate_errors()
         .clone(),
-      unstable: self.options.legacy_unstable_flag(),
+      unstable: cli_options.legacy_unstable_flag(),
       create_hmr_runner,
       create_coverage_collector,
     })