@teambit/install 0.0.0-0494a1bc1f010e387719d84abc70a90c0e5b6b7d

package/dist/install.main.runtime.js

@@ -0,0 +1,1397 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.InstallMain = void 0;
+function _pFilter() {
+  const data = _interopRequireDefault(require("p-filter"));
+  _pFilter = function () {
+    return data;
+  };
+  return data;
+}
+function _fsExtra() {
+  const data = _interopRequireWildcard(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _workspace() {
+  const data = require("@teambit/workspace.root-components");
+  _workspace = function () {
+    return data;
+  };
+  return data;
+}
+function _compiler() {
+  const data = require("@teambit/compiler");
+  _compiler = function () {
+    return data;
+  };
+  return data;
+}
+function _cli() {
+  const data = require("@teambit/cli");
+  _cli = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _yesno() {
+  const data = _interopRequireDefault(require("yesno"));
+  _yesno = function () {
+    return data;
+  };
+  return data;
+}
+function _workspace2() {
+  const data = require("@teambit/workspace");
+  _workspace2 = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _generator() {
+  const data = require("@teambit/generator");
+  _generator = function () {
+    return data;
+  };
+  return data;
+}
+function _pkgModules() {
+  const data = require("@teambit/pkg.modules.component-package-name");
+  _pkgModules = function () {
+    return data;
+  };
+  return data;
+}
+function _application() {
+  const data = require("@teambit/application");
+  _application = function () {
+    return data;
+  };
+  return data;
+}
+function _variants() {
+  const data = require("@teambit/variants");
+  _variants = function () {
+    return data;
+  };
+  return data;
+}
+function _component() {
+  const data = require("@teambit/component");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _dependenciesFs() {
+  const data = require("@teambit/dependencies.fs.linked-dependencies");
+  _dependenciesFs = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _harmony() {
+  const data = require("@teambit/harmony");
+  _harmony = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceModules() {
+  const data = require("@teambit/workspace.modules.node-modules-linker");
+  _workspaceModules = function () {
+    return data;
+  };
+  return data;
+}
+function _envs() {
+  const data = require("@teambit/envs");
+  _envs = function () {
+    return data;
+  };
+  return data;
+}
+function _ipcEvents() {
+  const data = require("@teambit/ipc-events");
+  _ipcEvents = function () {
+    return data;
+  };
+  return data;
+}
+function _componentIssues() {
+  const data = require("@teambit/component-issues");
+  _componentIssues = function () {
+    return data;
+  };
+  return data;
+}
+function _dependencyResolver() {
+  const data = require("@teambit/dependency-resolver");
+  _dependencyResolver = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceConfigFiles() {
+  const data = require("@teambit/workspace-config-files");
+  _workspaceConfigFiles = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@teambit/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _issues() {
+  const data = require("@teambit/issues");
+  _issues = function () {
+    return data;
+  };
+  return data;
+}
+function _componentPackageVersion() {
+  const data = require("@teambit/component-package-version");
+  _componentPackageVersion = function () {
+    return data;
+  };
+  return data;
+}
+function _aspectLoader() {
+  const data = require("@teambit/aspect-loader");
+  _aspectLoader = function () {
+    return data;
+  };
+  return data;
+}
+function _objectHash() {
+  const data = _interopRequireDefault(require("object-hash"));
+  _objectHash = function () {
+    return data;
+  };
+  return data;
+}
+function _bundler() {
+  const data = require("@teambit/bundler");
+  _bundler = function () {
+    return data;
+  };
+  return data;
+}
+function _ui() {
+  const data = require("@teambit/ui");
+  _ui = function () {
+    return data;
+  };
+  return data;
+}
+function _exceptions() {
+  const data = require("./exceptions");
+  _exceptions = function () {
+    return data;
+  };
+  return data;
+}
+function _install() {
+  const data = require("./install.aspect");
+  _install = function () {
+    return data;
+  };
+  return data;
+}
+function _pickOutdatedPkgs() {
+  const data = require("./pick-outdated-pkgs");
+  _pickOutdatedPkgs = function () {
+    return data;
+  };
+  return data;
+}
+function _link() {
+  const data = require("./link");
+  _link = function () {
+    return data;
+  };
+  return data;
+}
+function _install2() {
+  const data = _interopRequireDefault(require("./install.cmd"));
+  _install2 = function () {
+    return data;
+  };
+  return data;
+}
+function _uninstall() {
+  const data = _interopRequireDefault(require("./uninstall.cmd"));
+  _uninstall = function () {
+    return data;
+  };
+  return data;
+}
+function _update() {
+  const data = _interopRequireDefault(require("./update.cmd"));
+  _update = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class InstallMain {
+  constructor(dependencyResolver, logger, workspace, variants, compiler, envs, wsConfigFiles, aspectLoader, app, generator, preLinkSlot, preInstallSlot, postInstallSlot, ipcEvents, harmony) {
+    this.dependencyResolver = dependencyResolver;
+    this.logger = logger;
+    this.workspace = workspace;
+    this.variants = variants;
+    this.compiler = compiler;
+    this.envs = envs;
+    this.wsConfigFiles = wsConfigFiles;
+    this.aspectLoader = aspectLoader;
+    this.app = app;
+    this.generator = generator;
+    this.preLinkSlot = preLinkSlot;
+    this.preInstallSlot = preInstallSlot;
+    this.postInstallSlot = postInstallSlot;
+    this.ipcEvents = ipcEvents;
+    this.harmony = harmony;
+    _defineProperty(this, "visitedAspects", new Set());
+    _defineProperty(this, "oldNonLoadedEnvs", []);
+  }
+  /**
+   * Install dependencies for all components in the workspace
+   *
+   * @returns
+   * @memberof Workspace
+   */
+  async install(packages, options) {
+    // Check if external package manager mode is enabled
+    const workspaceConfig = this.workspace.getWorkspaceConfig();
+    const workspaceExtConfig = workspaceConfig.extensions.findExtension(_workspace2().WorkspaceAspect.id);
+    if (workspaceExtConfig?.config.externalPackageManager) {
+      await this.handleExternalPackageManagerPrompt();
+    }
+
+    // set workspace in install context
+    this.workspace.inInstallContext = true;
+    this.workspace.inInstallAfterPmContext = false;
+    if (packages && packages.length) {
+      await this._addPackages(packages, options);
+    }
+    if (options?.addMissingPeers) {
+      const compDirMap = await this.getComponentsDirectory([]);
+      const mergedRootPolicy = this.dependencyResolver.getWorkspacePolicy();
+      const depsFilterFn = await this.generateFilterFnForDepsFromLocalRemote();
+      const pmInstallOptions = {
+        dedupe: options?.dedupe,
+        copyPeerToRuntimeOnRoot: options?.copyPeerToRuntimeOnRoot ?? true,
+        copyPeerToRuntimeOnComponents: options?.copyPeerToRuntimeOnComponents ?? false,
+        dependencyFilterFn: depsFilterFn,
+        overrides: this.dependencyResolver.config.overrides,
+        hoistPatterns: this.dependencyResolver.config.hoistPatterns,
+        packageImportMethod: this.dependencyResolver.config.packageImportMethod
+      };
+      const missingPeers = await this.dependencyResolver.getMissingPeerDependencies(this.workspace.path, mergedRootPolicy, compDirMap, pmInstallOptions);
+      if (missingPeers) {
+        const missingPeerPackages = Object.entries(missingPeers).map(([peerName, range]) => `${peerName}@${range}`);
+        await this._addPackages(missingPeerPackages, options);
+      } else {
+        this.logger.console('No missing peer dependencies found.');
+      }
+    }
+    await (0, _pMapSeries().default)(this.preInstallSlot.values(), fn => fn(options)); // import objects if not disabled in options
+    const res = await this._installModules(options);
+    this.workspace.inInstallContext = false;
+    await this.ipcEvents.publishIpcEvent('onPostInstall');
+    return res;
+  }
+  registerPreLink(fn) {
+    this.preLinkSlot.register(fn);
+  }
+  registerPreInstall(fn) {
+    this.preInstallSlot.register(fn);
+  }
+  registerPostInstall(fn) {
+    this.postInstallSlot.register(fn);
+  }
+  async onComponentCreate(generateResults, installOptions) {
+    this.workspace.inInstallContext = true;
+    let runInstall = false;
+    let packages = [];
+    let installMissing = false;
+    const ids = generateResults.map(generateResult => {
+      if (generateResult.dependencies && generateResult.dependencies.length) {
+        packages = packages.concat(generateResult.dependencies);
+        runInstall = true;
+      }
+      if (generateResult.installMissingDependencies) {
+        installMissing = true;
+        runInstall = true;
+      }
+      if (generateResult.isApp || generateResult.isEnv) {
+        runInstall = true;
+      }
+      return generateResult.id;
+    });
+    const nonLoadedEnvs = [];
+    ids.map(id => this.workspace.clearComponentCache(id));
+    await (0, _pMapSeries().default)(ids, async id => {
+      const component = await this.workspace.get(id);
+      // const envId = await this.envs.getEnvId(component);
+      const envId = (await this.envs.calculateEnvId(component)).toString();
+      const isLoaded = this.envs.isEnvRegistered(envId);
+      if (!isLoaded) {
+        nonLoadedEnvs.push(envId);
+      }
+      return component;
+    });
+    if (nonLoadedEnvs.length) {
+      runInstall = true;
+    }
+    if (!runInstall) {
+      this.workspace.inInstallContext = false;
+      return;
+    }
+    // this.logger.console(
+    // `the following environments are not installed yet: ${nonLoadedEnvs.join(', ')}. installing them now...`
+    // );
+    await this.install(packages, _objectSpread(_objectSpread({}, installOptions), {}, {
+      addMissingDeps: installMissing,
+      skipIfExisting: true,
+      writeConfigFiles: false
+      // skipPrune: true,
+    }));
+  }
+  async _addPackages(packages, options) {
+    if (options?.lifecycleType === 'dev') {
+      throw new (_exceptions().DependencyTypeNotSupportedInPolicy)(options?.lifecycleType);
+    }
+    this.logger.debug(`installing the following packages: ${packages.join()}`);
+    const resolver = await this.dependencyResolver.getVersionResolver();
+    const resolvedPackagesP = packages.map(async packageName => {
+      try {
+        return await resolver.resolveRemoteVersion(packageName, {
+          rootDir: this.workspace.path
+        });
+      } catch (error) {
+        if (options?.skipUnavailable) {
+          return;
+        }
+        throw error;
+      }
+    });
+    const resolvedPackages = await Promise.all(resolvedPackagesP);
+    const newWorkspacePolicyEntries = [];
+    resolvedPackages.forEach(resolvedPackage => {
+      if (resolvedPackage?.version) {
+        const versionWithPrefix = this.dependencyResolver.getVersionWithSavePrefix({
+          version: resolvedPackage.version,
+          overridePrefix: options?.savePrefix,
+          wantedRange: resolvedPackage.wantedRange
+        });
+        newWorkspacePolicyEntries.push({
+          dependencyId: resolvedPackage.packageName,
+          value: {
+            version: versionWithPrefix
+          },
+          lifecycleType: options?.lifecycleType || 'runtime'
+        });
+      }
+    });
+    this.dependencyResolver.addToRootPolicy(newWorkspacePolicyEntries, {
+      updateExisting: options?.updateExisting ?? false,
+      skipIfExisting: options?.skipIfExisting ?? false
+    });
+    await this.dependencyResolver.persistConfig('install');
+  }
+  async _installModules(options) {
+    const pm = this.dependencyResolver.getPackageManager();
+    this.logger.console(`installing dependencies in workspace using ${pm?.name} (${_chalk().default.cyan(this.dependencyResolver.packageManagerName)})`);
+    this.logger.debug(`installing dependencies in workspace with options`, options);
+    const depsFilterFn = await this.generateFilterFnForDepsFromLocalRemote();
+    const hasRootComponents = this.dependencyResolver.hasRootComponents();
+    // TODO: pass get install options
+    const installer = this.dependencyResolver.getInstaller({});
+    const calcManifestsOpts = {
+      copyPeerToRuntimeOnComponents: options?.copyPeerToRuntimeOnComponents ?? false,
+      copyPeerToRuntimeOnRoot: options?.copyPeerToRuntimeOnRoot ?? true,
+      dedupe: !hasRootComponents && options?.dedupe,
+      dependencyFilterFn: depsFilterFn,
+      nodeLinker: this.dependencyResolver.nodeLinker()
+    };
+    const linkOpts = {
+      linkTeambitBit: true,
+      linkCoreAspects: this.dependencyResolver.linkCoreAspects(),
+      linkDepsResolvedFromEnv: !hasRootComponents,
+      linkNestedDepsInNM: !this.workspace.isLegacy && !hasRootComponents
+    };
+    const {
+      linkedRootDeps
+    } = await this.calculateLinks(linkOpts);
+    // eslint-disable-next-line prefer-const
+    let {
+      mergedRootPolicy,
+      componentsAndManifests: current
+    } = await this._getComponentsManifestsAndRootPolicy(installer, _objectSpread(_objectSpread({}, calcManifestsOpts), {}, {
+      addMissingDeps: options?.addMissingDeps,
+      skipUnavailable: options?.skipUnavailable,
+      linkedRootDeps
+    }));
+    const pmInstallOptions = _objectSpread(_objectSpread({}, calcManifestsOpts), {}, {
+      autoInstallPeers: this.dependencyResolver.config.autoInstallPeers,
+      dependenciesGraph: options?.dependenciesGraph,
+      includeOptionalDeps: options?.includeOptionalDeps,
+      neverBuiltDependencies: this.dependencyResolver.config.neverBuiltDependencies,
+      overrides: this.dependencyResolver.config.overrides,
+      hoistPatterns: this.dependencyResolver.config.hoistPatterns,
+      hoistInjectedDependencies: this.dependencyResolver.config.hoistInjectedDependencies,
+      packageImportMethod: this.dependencyResolver.config.packageImportMethod,
+      rootComponents: hasRootComponents,
+      updateAll: options?.updateAll,
+      optimizeReportForNonTerminal: options?.optimizeReportForNonTerminal,
+      lockfileOnly: options?.lockfileOnly
+    });
+    const prevManifests = new Set();
+    // TODO: this make duplicate
+    // this.logger.consoleSuccess();
+    const linkedDependencies = {
+      [this.workspace.path]: linkedRootDeps
+    };
+    const compDirMap = await this.getComponentsDirectory([]);
+    let installCycle = 0;
+    let hasMissingLocalComponents = true;
+    const forcedHarmonyVersion = this.dependencyResolver.harmonyVersionInRootPolicy();
+    /* eslint-disable no-await-in-loop */
+    do {
+      // In case there are missing local components,
+      // we'll need to make another round of installation as on the first round the missing local components
+      // are not added to the manifests.
+      // This is an issue when installation is done using root components.
+      hasMissingLocalComponents = hasRootComponents && hasComponentsFromWorkspaceInMissingDeps(current);
+      const {
+        dependenciesChanged
+      } = await installer.installComponents(this.workspace.path, current.manifests, mergedRootPolicy, current.componentDirectoryMap, {
+        linkedDependencies,
+        installTeambitBit: false,
+        forcedHarmonyVersion
+      }, pmInstallOptions);
+      this.workspace.inInstallAfterPmContext = true;
+      let cacheCleared = false;
+      await this.linkCodemods(compDirMap);
+      const oldNonLoadedEnvs = this.setOldNonLoadedEnvs();
+      await this.reloadMovedEnvs();
+      await this.reloadNonLoadedEnvs();
+      const shouldClearCacheOnInstall = this.shouldClearCacheOnInstall();
+      if (options?.compile ?? true) {
+        const compileStartTime = process.hrtime();
+        const compileOutputMessage = `compiling components`;
+        this.logger.setStatusLine(compileOutputMessage);
+        if (shouldClearCacheOnInstall) {
+          // We need to clear cache before compiling the components or it might compile them with the default env
+          // incorrectly in case the env was not loaded correctly before the installation.
+          // We don't want to clear the failed to load envs because we want to show the warning at the end
+          // await this.workspace.clearCache({ skipClearFailedToLoadEnvs: true });
+          await this.workspace.clearCache();
+          cacheCleared = true;
+        }
+        await this.compiler.compileOnWorkspace([], {
+          initiator: _compiler().CompilationInitiator.Install
+        });
+
+        // Right now we don't need to load extensions/execute load slot at this point
+        // await this.compiler.compileOnWorkspace([], { initiator: CompilationInitiator.Install }, undefined, {
+        //   executeLoadSlot: true,
+        //   loadExtensions: true,
+        // });
+        this.logger.consoleSuccess(compileOutputMessage, compileStartTime);
+      }
+      if (options?.writeConfigFiles ?? true) {
+        await this.tryWriteConfigFiles(!cacheCleared && shouldClearCacheOnInstall);
+      }
+      if (!dependenciesChanged) break;
+      if (!options?.recurringInstall) break;
+      if (!oldNonLoadedEnvs.length) break;
+      prevManifests.add(manifestsHash(current.manifests));
+      // If we run compile we do the clear cache before the compilation so no need to clean it again (it's an expensive
+      // operation)
+      if (!cacheCleared && shouldClearCacheOnInstall) {
+        // We need to clear cache before creating the new component manifests.
+        // this.workspace.consumer.componentLoader.clearComponentsCache();
+        // We don't want to clear the failed to load envs because we want to show the warning at the end
+        await this.workspace.clearCache({
+          skipClearFailedToLoadEnvs: true
+        });
+      }
+      current = await this._getComponentsManifests(installer, mergedRootPolicy, calcManifestsOpts);
+      installCycle += 1;
+    } while ((!prevManifests.has(manifestsHash(current.manifests)) || hasMissingLocalComponents) && installCycle < 5);
+    if (!options?.lockfileOnly && !options?.skipPrune) {
+      // We clean node_modules only after the last install.
+      // Otherwise, we might load an env from a location that we later remove.
+      try {
+        await installer.pruneModules(this.workspace.path);
+        // Ignoring the error here as it's not critical and we don't want to fail the install process
+      } catch (err) {
+        this.logger.error(`failed running pnpm prune with error`, err);
+      }
+      // After pruning we need reload moved envs, as during the pruning the old location might be deleted
+      await this.reloadMovedEnvs();
+    }
+    // this is now commented out because we assume we don't need it anymore.
+    // even when the env was not loaded before and it is loaded now, it should be fine because the dependencies-data
+    // is only about the auto-detect-deps. there are two more steps: version-resolution and apply-overrides that
+    // disregard the dependencies-cache.
+    // await this.workspace.consumer.componentFsCache.deleteAllDependenciesDataCache();
+    /* eslint-enable no-await-in-loop */
+    return current.componentDirectoryMap;
+  }
+  shouldClearCacheOnInstall() {
+    const nonLoadedEnvs = this.envs.getFailedToLoadEnvs();
+    return nonLoadedEnvs.length > 0;
+  }
+
+  /**
+   * This function is very important to fix some issues that might happen during the installation process.
+   * The case is the following:
+   * during/before the installation process we load some envs from their bit.env files
+   * this contains code like:
+   * protected tsconfigPath = require.resolve('./config/tsconfig.json');
+   * protected eslintConfigPath = require.resolve('./config/eslintrc.cjs');
+   * When we load that file, we calculated the resolved path, and it's stored in the env
+   * object instance.
+   * then later on during the install we move the env to another location (like bit roots)
+   * which points to a .pnpm folder with some peers, that changed during the install
+   * then when we take this env object and call write ws config for example
+   * or compile
+   * we use that resolved path to calculate the final tsconfig
+   * however that file is no longer exists which result in an error
+   * This function will check if an env folder doesn't exist anymore, and will re-load it
+   * from its new location.
+   * This usually happen when we have install running in the middle of the process followed
+   * by other bit ops.
+   * examples:
+   * bit new - which might run few installs then other ops.
+   * bit switch - which might run few installs then other ops, and potentially change the
+   * peer deps during the install.
+   * bit server (vscode plugin) - which keep the process always live, so any install ops
+   * that change the location, will cause the vscode plugin/bit server to crash later.
+   * @returns
+   */
+  async reloadMovedEnvs() {
+    this.logger.debug('reloadMovedEnvs');
+    const allEnvs = this.envs.getAllRegisteredEnvs();
+    const movedEnvs = await (0, _pFilter().default)(allEnvs, async env => {
+      if (!env.__path) return false;
+      const regularPathExists = await (0, _fsExtra().pathExists)(env.__path);
+      const resolvedPathExists = await (0, _fsExtra().pathExists)(env.__resolvedPath);
+      return !regularPathExists || !resolvedPathExists;
+    });
+    const idsToLoad = movedEnvs.map(env => env.id);
+    const componentIdsToLoad = idsToLoad.map(id => _component().ComponentID.fromString(id));
+    await this.reloadEnvs(componentIdsToLoad);
+  }
+  async reloadRegisteredEnvs() {
+    const allEnvs = this.envs.getAllRegisteredEnvs();
+    const idsToLoad = (0, _lodash().compact)(allEnvs.map(env => env.id));
+    const componentIdsToLoad = idsToLoad.map(id => _component().ComponentID.fromString(id));
+    await this.reloadEnvs(componentIdsToLoad);
+  }
+  async reloadNonLoadedEnvs() {
+    const nonLoadedEnvs = this.envs.getFailedToLoadEnvs();
+    const componentIdsToLoad = nonLoadedEnvs.map(id => _component().ComponentID.fromString(id));
+    await this.reloadEnvs(componentIdsToLoad);
+  }
+  async reloadEnvs(componentIdsToLoad) {
+    if (componentIdsToLoad.length && this.workspace) {
+      const aspects = await this.workspace.resolveAspects(undefined, componentIdsToLoad, {
+        requestedOnly: true,
+        excludeCore: true,
+        throwOnError: false
+        // Theoretically we should use skipDeps here, but according to implementation at the moment
+        // it will lead to plugins not load, and we need them to be loaded.
+        // This is a bug in the flow and should be fixed.
+        // skipDeps: true,
+      });
+      await Promise.all(aspects.map(async aspectDef => {
+        const id = aspectDef.component?.id;
+        if (!id) return;
+        await this.workspace.clearComponentCache(id);
+      }));
+      await this.reloadAspects(aspects || []);
+
+      // Keeping this here for now, it was removed as part of #9138 as now that we load envs of envs
+      // correctly first it seems to be not needed anymore.
+      // But there might be cases where it will be needed. So keeping it here for now.
+
+      // This is a very special case which we need to compile our envs before loading them correctly.
+      //   const grouped = groupBy(aspects, (aspectDef) => {
+      //     return aspectDef.component?.id.toStringWithoutVersion() === 'bitdev.general/envs/bit-env';
+      //   });
+      //   await this.reloadAspects(grouped.true || []);
+      //   const otherEnvs = grouped.false || [];
+      //   await Promise.all(
+      //     otherEnvs.map(async (aspectDef) => {
+      //       const id = aspectDef.component?.id;
+      //       if (!id) return;
+      //       await this.workspace.clearComponentCache(id);
+      //     })
+      //   );
+      //   await this.reloadAspects(grouped.false || []);
+    }
+  }
+  async reloadAspects(aspects) {
+    const groups = await this.groupAspectsToLoad(aspects);
+    // We need to make sure we load group by group and not in parallel
+    await (0, _pMapSeries().default)(groups, async group => {
+      await this.reloadOneAspectsGroup(group);
+    });
+  }
+  async reloadOneAspectsGroup(group) {
+    const aspects = group.aspects || [];
+    if (group.workspace && !group.envOfAspect) {
+      aspects.forEach(aspectDef => {
+        if (aspectDef.component?.id) {
+          this.workspace.clearComponentCache(aspectDef.component.id);
+        }
+      });
+    }
+    const loadedPlugins = (0, _lodash().compact)(await Promise.all(aspects.map(aspectDef => {
+      const localPath = aspectDef.aspectPath;
+      const component = aspectDef.component;
+      if (!component) return undefined;
+      const plugins = this.aspectLoader.getPlugins(component, localPath);
+      if (plugins.has()) {
+        return plugins.load(_cli().MainRuntime.name);
+      }
+    })));
+    await Promise.all(loadedPlugins.map(plugin => {
+      const runtime = plugin.getRuntime(_cli().MainRuntime);
+      return runtime?.provider(undefined, undefined, undefined, this.harmony);
+    }));
+  }
+
+  /**
+   * This function groups the components to aspects to load into groups.
+   * The order of the groups is important, the first group should be loaded first.
+   * The order inside the group is not important.
+   * The groups are:
+   * 1. aspects definitions without components (this should be an empty group, if it's not, we should check why).
+   * 2. aspects which are not in the workspace but in the scope / node modules.
+   * 3. envs of aspects (which are also aspects)
+   * 4. other aspects (the rest)
+   * @param aspects
+   * @returns
+   */
+  async groupAspectsToLoad(aspects) {
+    const groups = (0, _lodash().groupBy)(aspects, aspectDef => {
+      if (!aspectDef.component) return 'no-comp';
+      if (!this.workspace.hasId(aspectDef.component.id)) return 'scope';
+      return 'workspace';
+    });
+    const workspaceSubGroups = await this.regroupEnvsIdsFromTheList(groups.workspace || []);
+    return [{
+      comps: false,
+      workspace: false,
+      aspects: groups.noComp || []
+    }, {
+      comps: true,
+      workspace: false,
+      aspects: groups.scope || []
+    }, {
+      comps: true,
+      workspace: true,
+      envOfAspect: true,
+      aspects: workspaceSubGroups.envOfAspect
+    }, {
+      comps: true,
+      workspace: true,
+      aspects: workspaceSubGroups.otherAspects
+    }];
+  }
+  async regroupEnvsIdsFromTheList(aspects) {
+    const envsOfAspects = new Set();
+    await Promise.all(aspects.map(async aspectDef => {
+      if (!aspectDef.component) return;
+      const envId = aspectDef.component ? await this.envs.calculateEnvId(aspectDef.component) : undefined;
+      if (envId) {
+        envsOfAspects.add(envId.toString());
+      }
+    }));
+    const groups = (0, _lodash().groupBy)(aspects, aspectDef => {
+      const id = aspectDef.component?.id.toString();
+      const idWithoutVersion = aspectDef.component?.id.toStringWithoutVersion();
+      if (id && envsOfAspects.has(id) || idWithoutVersion && envsOfAspects.has(idWithoutVersion)) {
+        return 'envOfAspect';
+      }
+      return 'otherAspects';
+    });
+    return groups;
+  }
+  async _getComponentsManifestsAndRootPolicy(installer, options) {
+    const mergedRootPolicy = await this.addConfiguredAspectsToWorkspacePolicy();
+    await this.addConfiguredGeneratorEnvsToWorkspacePolicy(mergedRootPolicy);
+    const componentsAndManifests = await this._getComponentsManifests(installer, mergedRootPolicy, options);
+    if (!options?.addMissingDeps) {
+      return {
+        componentsAndManifests,
+        mergedRootPolicy
+      };
+    }
+    const rootDeps = new Set(Object.keys(_objectSpread(_objectSpread(_objectSpread({}, componentsAndManifests.manifests[this.workspace.path].devDependencies), componentsAndManifests.manifests[this.workspace.path].dependencies), options.linkedRootDeps)));
+    Object.values((0, _lodash().omit)(componentsAndManifests.manifests, [this.workspace.path])).forEach(manifest => {
+      if (manifest.name) {
+        rootDeps.add(manifest.name); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+      }
+    });
+    const addedNewPkgs = await this._addMissingPackagesToRootPolicy(rootDeps, {
+      skipUnavailable: options?.skipUnavailable
+    });
+    if (!addedNewPkgs) {
+      return {
+        componentsAndManifests,
+        mergedRootPolicy
+      };
+    }
+    const mergedRootPolicyWithMissingDeps = await this.addConfiguredAspectsToWorkspacePolicy();
+    await this.addConfiguredGeneratorEnvsToWorkspacePolicy(mergedRootPolicyWithMissingDeps);
+    return {
+      mergedRootPolicy: mergedRootPolicyWithMissingDeps,
+      componentsAndManifests: await this._getComponentsManifests(installer, mergedRootPolicyWithMissingDeps, options)
+    };
+  }
+
+  /**
+   * The function `tryWriteConfigFiles` attempts to write workspace config files, and if it fails, it logs an error
+   * message.
+   * @returns If the condition `!shouldWrite` is true, then nothing is being returned. Otherwise, if the `writeConfigFiles`
+   * function is successfully executed, nothing is being returned. If an error occurs during the execution of
+   * `writeConfigFiles`, an error message is being returned.
+   */
+  async tryWriteConfigFiles(clearCache) {
+    const shouldWrite = this.wsConfigFiles.isWorkspaceConfigWriteEnabled();
+    if (!shouldWrite) return;
+    if (clearCache) {
+      await this.workspace.clearCache({
+        skipClearFailedToLoadEnvs: true
+      });
+    }
+    const {
+      err
+    } = await this.wsConfigFiles.writeConfigFiles({
+      clean: true,
+      silent: true,
+      dedupe: true,
+      throw: false
+    });
+    if (err) {
+      this.logger.consoleFailure(`failed generating workspace config files, please run "bit ws-config write" manually. error: ${err.message}`);
+    }
+  }
+  async addConfiguredAspectsToWorkspacePolicy() {
+    const rootPolicy = this.dependencyResolver.getWorkspacePolicy();
+    const aspectsPackages = await this.workspace.getConfiguredUserAspectsPackages({
+      externalsOnly: true
+    });
+    aspectsPackages.forEach(aspectsPackage => {
+      rootPolicy.add({
+        dependencyId: aspectsPackage.packageName,
+        value: {
+          version: aspectsPackage.version
+        },
+        lifecycleType: 'runtime'
+      },
+      // If it's already exist from the root, take the version from the root policy
+      {
+        skipIfExisting: true
+      });
+    });
+    return rootPolicy;
+  }
+  async addConfiguredGeneratorEnvsToWorkspacePolicy(rootPolicy) {
+    const configuredEnvs = this.generator.getConfiguredEnvs();
+    const resolvedEnvs = (0, _lodash().compact)(await Promise.all(configuredEnvs.map(async envIdStr => {
+      if (this.envs.isCoreEnv(envIdStr)) {
+        return undefined;
+      }
+      const parsedId = await this.workspace.resolveComponentId(envIdStr);
+      // If we have the env in the workspace, we don't want to install it
+      const inWs = await this.workspace.hasId(parsedId);
+      if (inWs) {
+        return undefined;
+      }
+      const comps = await this.workspace.importAndGetMany([parsedId], `to get the env ${parsedId.toString()} for installation`);
+      const idWithVersion = await this.workspace.resolveEnvIdWithPotentialVersionForConfig(parsedId);
+      const version = idWithVersion.split('@')[1] || '*';
+      const packageName = this.dependencyResolver.getPackageName(comps[0]);
+      return {
+        packageName,
+        version
+      };
+    })));
+    resolvedEnvs.forEach(env => {
+      rootPolicy.add({
+        dependencyId: env.packageName,
+        value: {
+          version: env.version
+        },
+        lifecycleType: 'runtime'
+      },
+      // If it's already exist from the root, take the version from the root policy
+      {
+        skipIfExisting: true
+      });
+    });
+  }
+  async _addMissingPackagesToRootPolicy(rootDeps, options) {
+    const packages = await this._getMissingPackagesWithoutRootDeps(rootDeps);
+    if (packages && packages.length) {
+      await this._addPackages(packages, options);
+    }
+    return packages.length > 0;
+  }
+  async _getMissingPackagesWithoutRootDeps(rootDeps) {
+    const packages = await this._getAllMissingPackages();
+    return packages.filter(pkg => !rootDeps.has(pkg));
+  }
+  async _getAllMissingPackages() {
+    const comps = await this.workspace.list();
+    return (0, _lodash().uniq)(comps.map(comp => {
+      const data = comp.state.issues.getIssue(_componentIssues().IssuesClasses.MissingPackagesDependenciesOnFs)?.data || [];
+      return data.map(d => d.missingPackages).flat();
+    }).flat());
+  }
+  async _getComponentsManifests(dependencyInstaller, rootPolicy, installOptions) {
+    const componentDirectoryMap = await this.getComponentsDirectory([]);
+    let manifests = await dependencyInstaller.getComponentManifests(_objectSpread(_objectSpread({}, installOptions), {}, {
+      componentDirectoryMap,
+      rootPolicy,
+      rootDir: this.workspace.path,
+      referenceLocalPackages: this.dependencyResolver.hasRootComponents() && installOptions.nodeLinker === 'isolated'
+    }));
+    if (this.dependencyResolver.hasRootComponents()) {
+      const rootManifests = await this._getRootManifests(manifests);
+      await this._updateRootDirs(Object.keys(rootManifests));
+      manifests = _objectSpread(_objectSpread({}, manifests), rootManifests);
+    }
+    return {
+      componentDirectoryMap,
+      manifests
+    };
+  }
+  setOldNonLoadedEnvs() {
+    const nonLoadedEnvs = this.envs.getFailedToLoadEnvs();
+    const envsWithoutManifest = Array.from(this.dependencyResolver.envsWithoutManifest);
+    const oldNonLoadedEnvs = (0, _lodash().intersection)(nonLoadedEnvs, envsWithoutManifest);
+    this.oldNonLoadedEnvs = oldNonLoadedEnvs;
+    return oldNonLoadedEnvs;
+  }
+
+  /**
+   * This function returns a list of old non-loaded environments names.
+   * @returns an array of strings called `oldNonLoadedEnvs`. This array contains the names of environment variables that
+   * failed to load as extensions and are also don't have an env.jsonc file.
+   * If this list is not empty, then the user might need to run another install to make sure all dependencies resolved
+   * correctly
+   */
+  getOldNonLoadedEnvs() {
+    return this.oldNonLoadedEnvs;
+  }
+  async _updateRootDirs(rootDirs) {
+    try {
+      const existingDirs = await _fsExtra().default.readdir(this.workspace.rootComponentsPath);
+      await Promise.all(existingDirs.map(async dirName => {
+        const dirPath = _path().default.join(this.workspace.rootComponentsPath, dirName);
+        if (!rootDirs.includes(dirPath)) {
+          await _fsExtra().default.remove(dirPath);
+        }
+      }));
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+    await Promise.all(rootDirs.map(dirPath => _fsExtra().default.mkdir(dirPath, {
+      recursive: true
+    })));
+  }
+  async _getRootManifests(manifests) {
+    const nonRootManifests = Object.values(manifests).filter(({
+      name
+    }) => name !== 'workspace');
+    const workspaceDeps = this.dependencyResolver.getWorkspaceDepsOfBitRoots(nonRootManifests);
+    const workspaceDepsMeta = Object.keys(workspaceDeps).reduce((acc, depName) => {
+      acc[depName] = {
+        injected: true
+      };
+      return acc;
+    }, {});
+    const envManifests = await this._getEnvManifests(workspaceDeps, workspaceDepsMeta);
+    const appManifests = await this._getAppManifests(manifests, workspaceDeps, workspaceDepsMeta);
+    return _objectSpread(_objectSpread({}, envManifests), appManifests);
+  }
+  async _getEnvManifests(workspaceDeps, workspaceDepsMeta) {
+    const envs = await this._getAllUsedEnvIds();
+    return Object.fromEntries(await Promise.all(envs.map(async envId => {
+      return [await this.getRootComponentDirByRootId(this.workspace.rootComponentsPath, envId), {
+        dependencies: _objectSpread(_objectSpread(_objectSpread({}, await this._getEnvDependencies(envId)), workspaceDeps), await this._getEnvPackage(envId)),
+        dependenciesMeta: workspaceDepsMeta,
+        installConfig: {
+          hoistingLimits: 'workspaces'
+        }
+      }];
+    })));
+  }
+  async _getEnvDependencies(envId) {
+    const policy = await this.dependencyResolver.getEnvPolicyFromEnvId(envId);
+    if (!policy) return {};
+    return Object.fromEntries(policy.selfPolicy.entries.filter(({
+      force,
+      value
+    }) => force && value.version !== '-').map(({
+      dependencyId,
+      value
+    }) => [dependencyId, value.version]));
+  }
+
+  /**
+   * Return the package name of the env with its version.
+   * (only if the env is not a core env and is not in the workspace)
+   * @param envId
+   * @returns
+   */
+  async _getEnvPackage(envId) {
+    if (this.envs.isCoreEnv(envId.toStringWithoutVersion())) return undefined;
+    const inWs = await this.workspace.hasId(envId);
+    if (inWs) return undefined;
+    const envComponent = await this.envs.getEnvComponentByEnvId(envId.toString(), envId.toString());
+    if (!envComponent) return undefined;
+    const packageName = this.dependencyResolver.getPackageName(envComponent);
+    const version = envId.version;
+    const finalVersion = (0, _componentPackageVersion().snapToSemver)(version);
+    return {
+      [packageName]: finalVersion
+    };
+  }
+  async _getAppManifests(manifests, workspaceDeps, workspaceDepsMeta) {
+    return Object.fromEntries((0, _lodash().compact)(await Promise.all((await this.app.listAppsComponents()).map(async app => {
+      const appPkgName = this.dependencyResolver.getPackageName(app);
+      const appManifest = Object.values(manifests).find(({
+        name
+      }) => name === appPkgName);
+      if (!appManifest) return null;
+      const envId = await this.envs.calculateEnvId(app);
+      return [await this.getRootComponentDirByRootId(this.workspace.rootComponentsPath, app.id), _objectSpread(_objectSpread({}, (0, _lodash().omit)(appManifest, ['name', 'version'])), {}, {
+        dependencies: _objectSpread(_objectSpread(_objectSpread({}, await this._getEnvDependencies(envId)), appManifest.dependencies), workspaceDeps),
+        dependenciesMeta: _objectSpread(_objectSpread({}, appManifest.dependenciesMeta), workspaceDepsMeta),
+        installConfig: {
+          hoistingLimits: 'workspaces'
+        }
+      })];
+    }))));
+  }
+  async _getAllUsedEnvIds() {
+    const envs = new Map();
+    const components = await this.workspace.list();
+    await (0, _pMapSeries().default)(components, async component => {
+      const envId = await this.envs.calculateEnvId(component);
+      envs.set(envId.toString(), envId);
+    });
+    return Array.from(envs.values());
+  }
+
+  /**
+   * Updates out-of-date dependencies in the workspace.
+   *
+   * @param options.all {Boolean} updates all outdated dependencies without showing a prompt.
+   */
+  async updateDependencies(options) {
+    const componentPolicies = await this.workspace.getComponentsWithDependencyPolicies();
+    const variantPoliciesByPatterns = this.workspace.variantPatternsToDepPolicesDict();
+    const components = await this.workspace.list();
+    const outdatedPkgs = await this.dependencyResolver.getOutdatedPkgsFromPolicies({
+      rootDir: this.workspace.path,
+      variantPoliciesByPatterns,
+      componentPolicies,
+      components,
+      patterns: options.patterns,
+      forceVersionBump: options.forceVersionBump
+    });
+    if (outdatedPkgs == null) {
+      this.logger.consoleFailure('No dependencies found that match the patterns');
+      return null;
+    }
+    let outdatedPkgsToUpdate;
+    if (options.all) {
+      outdatedPkgsToUpdate = outdatedPkgs;
+    } else {
+      this.logger.off();
+      outdatedPkgsToUpdate = await (0, _pickOutdatedPkgs().pickOutdatedPkgs)(outdatedPkgs);
+      this.logger.on();
+    }
+    if (outdatedPkgsToUpdate.length === 0) {
+      this.logger.consoleSuccess('No outdated dependencies found');
+      if (options.forceVersionBump === 'compatible') {
+        this.logger.console("If you want to find new versions that don't match the current version ranges, retry with the --latest flag");
+      }
+      return null;
+    }
+    const {
+      updatedVariants,
+      updatedComponents
+    } = this.dependencyResolver.applyUpdates(outdatedPkgsToUpdate, {
+      variantPoliciesByPatterns
+    });
+    await this._updateVariantsPolicies(updatedVariants);
+    await this._updateComponentsConfig(updatedComponents);
+    await this.workspace._reloadConsumer();
+    return this._installModules({
+      dedupe: true
+    });
+  }
+  async addDuplicateComponentAndPackageIssue(components) {
+    const workspacePolicy = this.dependencyResolver.getWorkspacePolicy();
+    components.forEach(component => {
+      if (component.state._consumer.removed) return;
+      const pkgName = (0, _pkgModules().componentIdToPackageName)(component.state._consumer);
+      const found = workspacePolicy.find(pkgName);
+      if (found) {
+        component.state.issues.getOrCreate(_componentIssues().IssuesClasses.DuplicateComponentAndPackage).data = found.dependencyId;
+      }
+    });
+  }
+  async _updateComponentsConfig(updatedComponents) {
+    if (updatedComponents.length === 0) return;
+    await Promise.all(updatedComponents.map(({
+      componentId,
+      config
+    }) => {
+      return this.workspace.addSpecificComponentConfig(componentId, _dependencyResolver().DependencyResolverAspect.id, config, {
+        shouldMergeWithExisting: true,
+        shouldMergeWithPrevious: true
+      });
+    }));
+    await this.workspace.bitMap.write('update (dependencies)');
+  }
+  async _updateVariantsPolicies(updateVariantPolicies) {
+    const variantPatterns = this.variants.raw();
+    for (const variantPattern of updateVariantPolicies) {
+      this.variants.setExtension(variantPattern, _dependencyResolver().DependencyResolverAspect.id, variantPatterns[variantPattern][_dependencyResolver().DependencyResolverAspect.id], {
+        overrideExisting: true
+      });
+    }
+    await this.dependencyResolver.persistConfig('update dependencies');
+  }
+
+  /**
+   * Uninstall the specified packages from dependencies.
+   *
+   * @param {string[]} the list of packages that should be removed from dependencies.
+   */
+  async uninstallDependencies(packages) {
+    this.dependencyResolver.removeFromRootPolicy(packages);
+    await this.dependencyResolver.persistConfig('uninstall dependencies');
+    return this._installModules({
+      dedupe: true
+    });
+  }
+
+  /**
+   * This function returns all the locations of the external links that should be created inside node_modules.
+   * This information may then be passed to the package manager, which will create the links on its own.
+   */
+  async calculateLinks(options = {}) {
+    await (0, _pMapSeries().default)(this.preLinkSlot.values(), fn => fn(options)); // import objects if not disabled in options
+    const compDirMap = await this.getComponentsDirectory([]);
+    const linker = this.dependencyResolver.getLinker({
+      rootDir: this.workspace.path,
+      linkingOptions: options
+    });
+    const {
+      linkResults: res,
+      linkedRootDeps
+    } = await linker.calculateLinkedDeps(this.workspace.path, compDirMap, options);
+    const workspaceRes = res;
+    const legacyResults = await this.linkCodemods(compDirMap, options);
+    workspaceRes.legacyLinkResults = legacyResults.linksResults;
+    workspaceRes.legacyLinkCodemodResults = legacyResults.codemodResults;
+    if (this.dependencyResolver.hasRootComponents() && options.linkToBitRoots) {
+      await this._linkAllComponentsToBitRoots(compDirMap);
+    }
+    return {
+      linkResults: res,
+      linkedRootDeps
+    };
+  }
+  async linkCodemods(compDirMap, options) {
+    const bitIds = compDirMap.toArray().map(([component]) => component.id);
+    return (0, _workspaceModules().linkToNodeModulesWithCodemod)(this.workspace, bitIds, options?.rewire ?? false);
+  }
+  async link(options = {}) {
+    const {
+      linkResults,
+      linkedRootDeps
+    } = await this.calculateLinks(options);
+    await (0, _dependenciesFs().createLinks)(options.linkToDir ?? this.workspace.path, linkedRootDeps, {
+      avoidHardLink: true,
+      skipIfSymlinkValid: true
+    });
+    return linkResults;
+  }
+  async _linkAllComponentsToBitRoots(compDirMap) {
+    const envs = await this._getAllUsedEnvIds();
+    const apps = (await this.app.listAppsComponents()).map(component => component.id);
+    await Promise.all([...envs, ...apps].map(async id => {
+      const dir = await this.getRootComponentDirByRootId(this.workspace.rootComponentsPath, id);
+      await _fsExtra().default.mkdirp(dir);
+    }));
+    await (0, _workspace().linkPkgsToRootComponents)({
+      rootComponentsPath: this.workspace.rootComponentsPath,
+      workspacePath: this.workspace.path
+    }, compDirMap.components.map(component => this.dependencyResolver.getPackageName(component)));
+  }
+  async getRootComponentDirByRootId(rootComponentsPath, rootComponentId) {
+    // Root directories for local envs and apps are created without their version number.
+    // This is done in order to avoid changes to the lockfile after such components are tagged.
+    const id = this.workspace.hasId(rootComponentId) ? rootComponentId.toStringWithoutVersion() : rootComponentId.toString();
+    return (0, _workspace().getRootComponentDir)(rootComponentsPath, id);
+  }
+
+  /**
+   * Generate a filter to pass to the installer
+   * This will filter deps which are come from remotes which defined in scope.json
+   * those components comes from local remotes, usually doesn't have a package in a registry
+   * so no reason to try to install them (it will fail)
+   */
+  async generateFilterFnForDepsFromLocalRemote() {
+    const remotes = await this.workspace.scope.getRemoteScopes();
+    const reg = await this.dependencyResolver.getRegistries();
+    const packageScopes = Object.keys(reg.scopes);
+    return dependencyList => {
+      const filtered = dependencyList.filter(dep => {
+        if (!(dep instanceof _dependencyResolver().ComponentDependency)) {
+          return true;
+        }
+        if (remotes.isHub(dep.componentId.scope)) {
+          return true;
+        }
+        if (packageScopes.some(scope => dep.packageName.startsWith(`@${scope}/`))) {
+          return true;
+        }
+        return false;
+      });
+      return filtered;
+    };
+  }
+  async getComponentsDirectory(ids) {
+    const components = ids.length ? await this.workspace.getMany(ids) : await this.workspace.list(undefined, {
+      loadSeedersAsAspects: false
+    });
+    return _component().ComponentMap.as(components, component => this.workspace.componentDir(component.id));
+  }
+  async onRootAspectAddedSubscriber(_aspectId, inWs) {
+    if (!inWs) {
+      await this.install();
+    }
+  }
+  async onAspectsResolveSubscriber(aspectComponents) {
+    let needLink = false;
+    let needInstall = false;
+    const promises = aspectComponents.map(async aspectComponent => {
+      const aspectIdStr = aspectComponent.id.toString();
+      if (this.visitedAspects.has(aspectIdStr)) return;
+      this.visitedAspects.add(aspectIdStr);
+      const packagePath = await this.workspace.getComponentPackagePath(aspectComponent);
+      const exists = await (0, _fsExtra().pathExists)(packagePath);
+      if (!exists) {
+        const inWs = await this.workspace.hasId(aspectComponent.id);
+        if (inWs) {
+          needLink = true;
+        } else {
+          needInstall = true;
+        }
+      }
+    });
+    await Promise.all(promises);
+    if (needInstall) {
+      await this.install();
+      return;
+    }
+    if (needLink) {
+      await this.link();
+    }
+  }
+  async onComponentChange(component) {
+    const isEnv = this.envs.isEnv(component);
+    if (isEnv) {
+      await this.reloadEnvs([component.id]);
+    }
+  }
+  static async provider([dependencyResolver, workspace, loggerExt, variants, cli, compiler, issues, envs, app, ipcEvents, generator, wsConfigFiles, aspectLoader, bundler, ui], _, [preLinkSlot, preInstallSlot, postInstallSlot], harmony) {
+    const logger = loggerExt.createLogger(_install().InstallAspect.id);
+    const installExt = new InstallMain(dependencyResolver, logger, workspace, variants, compiler, envs, wsConfigFiles, aspectLoader, app, generator, preLinkSlot, preInstallSlot, postInstallSlot, ipcEvents, harmony);
+    ipcEvents.registerGotEventSlot(async eventName => {
+      if (eventName !== 'onPostInstall') return;
+      logger.debug('got onPostInstall event, clear workspace and all components cache');
+      await workspace.clearCache();
+      await installExt.reloadMovedEnvs();
+      await (0, _pMapSeries().default)(postInstallSlot.values(), fn => fn());
+    });
+    if (issues) {
+      issues.registerAddComponentsIssues(installExt.addDuplicateComponentAndPackageIssue.bind(installExt));
+    }
+    generator.registerOnComponentCreate(installExt.onComponentCreate.bind(installExt));
+    const commands = [new (_install2().default)(installExt, workspace, logger), new (_uninstall().default)(installExt), new (_update().default)(installExt), new (_link().LinkCommand)(installExt, workspace, logger)];
+    // For now do not automate installation during aspect resolving
+    // workspace.registerOnAspectsResolve(installExt.onAspectsResolveSubscriber.bind(installExt));
+    if (workspace) {
+      workspace.registerOnRootAspectAdded(installExt.onRootAspectAddedSubscriber.bind(installExt));
+      workspace.registerOnComponentChange(installExt.onComponentChange.bind(installExt));
+    }
+    installExt.registerPostInstall(async () => {
+      if (!ui.getUIServer()) {
+        return;
+      }
+      const components = await workspace.list();
+      await bundler.addNewDevServers(components);
+    });
+    cli.register(...commands);
+    return installExt;
+  }
+  async handleExternalPackageManagerPrompt() {
+    this.logger.clearStatusLine();
+    const question = `Hi, I noticed you use external package manager mode. Do you want to use Bit's package manager instead? [yes(y)/no(n)]`;
+    const shouldSwitchToBitPM = await (0, _yesno().default)({
+      question
+    });
+    if (!shouldSwitchToBitPM) {
+      throw new Error('External package manager mode is enabled. Please use your preferred package manager (npm, yarn, pnpm) to install dependencies instead of "bit install".');
+    }
+
+    // User chose to switch to Bit's package manager
+    await this.disableExternalPackageManagerMode();
+  }
+  async disableExternalPackageManagerMode() {
+    try {
+      // Get the workspace config
+      const workspaceConfig = this.workspace.getWorkspaceConfig();
+
+      // Remove externalPackageManager property
+      const workspaceExtConfig = workspaceConfig.extensions.findExtension(_workspace2().WorkspaceAspect.id);
+      if (workspaceExtConfig?.config.externalPackageManager) {
+        delete workspaceExtConfig.config.externalPackageManager;
+      }
+
+      // Restore default settings
+      const depResolverExt = workspaceConfig.extensions.findExtension('teambit.dependencies/dependency-resolver');
+      if (depResolverExt) {
+        depResolverExt.config.rootComponent = true;
+      }
+
+      // Enable workspace config write
+      const workspaceConfigFilesExt = workspaceConfig.extensions.findExtension('teambit.workspace/workspace-config-files');
+      if (workspaceConfigFilesExt) {
+        workspaceConfigFilesExt.config.enableWorkspaceConfigWrite = true;
+      }
+
+      // Remove postInstall script from package.json (preserve user's existing scripts)
+      await this.removePostInstallScript();
+
+      // Write the updated config
+      await workspaceConfig.write();
+      this.logger.console(_chalk().default.green('✓ Successfully switched to Bit package manager mode'));
+    } catch (error) {
+      this.logger.console(_chalk().default.red('✗ Failed to switch to Bit package manager mode'));
+      throw error;
+    }
+  }
+  async removePostInstallScript() {
+    try {
+      const packageJsonPath = _path().default.join(this.workspace.path, 'package.json');
+      const packageJsonExists = await (0, _fsExtra().pathExists)(packageJsonPath);
+      if (!packageJsonExists) {
+        return;
+      }
+      const packageJson = await _fsExtra().default.readJson(packageJsonPath);
+
+      // Only remove our specific postInstall script, preserve user's custom scripts
+      if (packageJson.scripts?.postinstall === 'bit link && bit compile') {
+        delete packageJson.scripts.postinstall;
+
+        // Clean up empty scripts object
+        if (Object.keys(packageJson.scripts).length === 0) {
+          delete packageJson.scripts;
+        }
+        await _fsExtra().default.writeJson(packageJsonPath, packageJson, {
+          spaces: 2
+        });
+      }
+    } catch {
+      this.logger.console(_chalk().default.yellow('⚠ Warning: Could not remove postInstall script from package.json'));
+    }
+  }
+}
+exports.InstallMain = InstallMain;
+_defineProperty(InstallMain, "slots", [_harmony().Slot.withType(), _harmony().Slot.withType(), _harmony().Slot.withType()]);
+_defineProperty(InstallMain, "dependencies", [_dependencyResolver().DependencyResolverAspect, _workspace2().WorkspaceAspect, _logger().LoggerAspect, _variants().VariantsAspect, _cli().CLIAspect, _compiler().CompilerAspect, _issues().IssuesAspect, _envs().EnvsAspect, _application().ApplicationAspect, _ipcEvents().IpcEventsAspect, _generator().GeneratorAspect, _workspaceConfigFiles().WorkspaceConfigFilesAspect, _aspectLoader().AspectLoaderAspect, _bundler().BundlerAspect, _ui().UIAspect]);
+_defineProperty(InstallMain, "runtime", _cli().MainRuntime);
+function hasComponentsFromWorkspaceInMissingDeps({
+  componentDirectoryMap,
+  manifests
+}) {
+  const missingDeps = new Set(componentDirectoryMap.toArray().map(([{
+    state
+  }]) => {
+    const issue = state.issues.getIssue(_componentIssues().IssuesClasses.MissingPackagesDependenciesOnFs);
+    if (!issue) return [];
+    return issue.data.map(d => d.missingPackages).flat();
+  }).flat());
+  return Object.values(manifests).some(({
+    name
+  }) => name && missingDeps.has(name));
+}
+_install().InstallAspect.addRuntime(InstallMain);
+var _default = exports.default = InstallMain;
+function manifestsHash(manifests) {
+  // We don't care if the type of the dependency changes as it doesn't change the node_modules structure
+  const depsByProjectPaths = (0, _lodash().mapValues)(manifests, manifest => _objectSpread(_objectSpread({}, manifest.devDependencies), manifest.dependencies));
+  return (0, _objectHash().default)(depsByProjectPaths);
+}
+
+//# sourceMappingURL=install.main.runtime.js.map