@teambit/doctor 0.0.0-00997c6fe4e832b4e5a012dc136eed546275ebcb

package/core-diagnoses/broken-symlink-files.ts

@@ -0,0 +1,78 @@
+import fs from 'fs-extra';
+import { globSync } from 'glob';
+import path from 'path';
+import { loadConsumer } from '@teambit/legacy.consumer';
+import { Scope } from '@teambit/legacy.scope';
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+import { uniq } from 'lodash';
+
+type BrokenSymlink = { symlinkPath: string; brokenPath: string; pathToDelete: string };
+export const DIAGNOSIS_NAME = 'check environment symlinks';
+
+export default class BrokenSymlinkFiles extends Diagnosis {
+  name = DIAGNOSIS_NAME;
+  description = 'validate generated symlinks for workspace environments';
+  category = 'local environments';
+
+  _formatSymptoms(bareResult: ExamineBareResult): string {
+    if (!bareResult.data) throw new Error('BrokenSymlinkFiles, bareResult.data is missing');
+    const toString = bareResult.data.brokenSymlinks
+      .map(
+        (brokenSymlink) => `symlink path: "${brokenSymlink.symlinkPath}", broken link: "${brokenSymlink.brokenPath}"`
+      )
+      .join('\n');
+    return `the following symlinks points to non-existing paths\n${toString}`;
+  }
+
+  _formatManualTreat(bareResult: ExamineBareResult) {
+    if (!bareResult.data) throw new Error('BrokenSymlinkFiles, bareResult.data is missing');
+    const toString = uniq(bareResult.data.brokenSymlinks.map((b) => b.pathToDelete)).join('\n');
+    return `please delete the following paths:\n${toString}`;
+  }
+
+  async _runExamine(): Promise<ExamineBareResult> {
+    const consumer = await loadConsumer();
+    const envComponentsDir = path.join(consumer.scope.getPath(), Scope.getComponentsRelativePath());
+    const potentialSymlinks = globSync('**/node_modules/@bit/**', { cwd: envComponentsDir });
+    const potentialSymlinksAbs = potentialSymlinks.map((p) => path.join(envComponentsDir, p));
+    const brokenSymlinks: BrokenSymlink[] = [];
+    const results = potentialSymlinksAbs.map(async (potentialSymlink) => {
+      const link = await this._getLinkIfExist(potentialSymlink);
+      if (!link) return;
+      const exists = await fs.pathExists(link);
+      if (exists) return;
+      const brokenSymlink = {
+        symlinkPath: potentialSymlink,
+        brokenPath: link,
+        pathToDelete: this._getPathToDelete(potentialSymlink),
+      };
+      brokenSymlinks.push(brokenSymlink);
+    });
+    await Promise.all(results);
+    return {
+      valid: brokenSymlinks.length === 0,
+      data: {
+        brokenSymlinks,
+      },
+    };
+  }
+
+  async _getLinkIfExist(symlinkPath: string): Promise<string | null | undefined> {
+    try {
+      const link = await fs.readlink(symlinkPath);
+      return link;
+    } catch {
+      // probably not a symlink
+      return null;
+    }
+  }
+
+  /**
+   * deleting the environment directory causes Bit to reinstall it next time
+   */
+  _getPathToDelete(symlinkPath: string): string {
+    const envDirectory = symlinkPath.split(path.join('node_modules', '@bit'))[0];
+    return envDirectory.slice(0, -1); // remove the last slash
+  }
+}

package/core-diagnoses/orphan-symlink-objects.ts

@@ -0,0 +1,50 @@
+import { ComponentIdList } from '@teambit/component-id';
+import { loadConsumer } from '@teambit/legacy.consumer';
+import { ModelComponent, Symlink } from '@teambit/objects';
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+
+export const DIAGNOSIS_NAME = 'check orphan refs';
+export default class OrphanSymlinkObjects extends Diagnosis {
+  name = DIAGNOSIS_NAME;
+  description = 'checks for empty internal refs in local workspace';
+  category = 'internal store';
+
+  _formatSymptoms(bareResult: ExamineBareResult): string {
+    if (!bareResult.data) throw new Error('OrphanSymlinkObjects, bareResult.data is missing');
+    return `the following refs points to non-existing components "${bareResult.data.orphanSymlinks.toString()}"`;
+  }
+
+  _formatManualTreat(bareResult: ExamineBareResult) {
+    if (!bareResult.data) throw new Error('OrphanSymlinkObjects, bareResult.data is missing');
+    return `please delete the following paths:\n${bareResult.data.objectsToDelete.join('\n')}`;
+  }
+
+  async _runExamine(): Promise<ExamineBareResult> {
+    const consumer = await loadConsumer();
+    const symlinks = await consumer.scope.objects.list([Symlink]);
+    const orphanSymlinks = new ComponentIdList();
+    const objectsToDelete = [];
+    await Promise.all(
+      symlinks.map(async (symlink) => {
+        // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+        const realComponentId: ComponentID = symlink.getRealComponentId();
+        const realModelComponent = ModelComponent.fromBitId(realComponentId);
+        const foundComponent = await consumer.scope.objects.load(realModelComponent.hash());
+        if (!foundComponent) {
+          orphanSymlinks.push(realComponentId);
+          // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+          objectsToDelete.push(consumer.scope.objects.objectPath(symlink.hash()));
+        }
+      })
+    );
+
+    return {
+      valid: orphanSymlinks.length === 0,
+      data: {
+        orphanSymlinks,
+        objectsToDelete,
+      },
+    };
+  }
+}

package/core-diagnoses/validate-bit-version.ts

@@ -0,0 +1,55 @@
+import semver from 'semver';
+import { listRemote } from '@teambit/bvm.list';
+import { getBitVersion } from '@teambit/bit.get-bit-version';
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+
+export default class ValidateBitVersion extends Diagnosis {
+  name = 'validate bit version';
+  description = 'validate that bit version is up to date';
+  category = 'core';
+
+  _formatSymptoms(bareResult: ExamineBareResult): string {
+    if (!bareResult.data) throw new Error('ValidateBitVersion, bareResult.data is missing');
+    if (!bareResult.data.latestVersion) {
+      return 'could not fetch bit latest version';
+    }
+    return `bit is not up to date.
+  your version: ${bareResult.data.currentVersion}
+  latest version: ${bareResult.data.latestVersion}`;
+  }
+
+  _formatManualTreat(bareResult: ExamineBareResult) {
+    if (!bareResult.data) throw new Error('ValidateBitVersion, bareResult.data is missing');
+    if (!bareResult.data.latestVersion) {
+      return 'please make sure you have an internet connection';
+    }
+    return 'please upgrade your bit version (bvm upgrade)';
+  }
+
+  async _runExamine(): Promise<ExamineBareResult> {
+    const bitRemoteVersionOnBvm = await listRemote({ limit: 1 });
+    const bitLatestVersion = bitRemoteVersionOnBvm.entries[0].version;
+    const bitCurrentVersion = getBitVersion();
+    if (bitLatestVersion) {
+      if (semver.lt(bitCurrentVersion, bitLatestVersion)) {
+        return {
+          valid: false,
+          data: {
+            latestVersion: bitLatestVersion,
+            currentVersion: bitCurrentVersion,
+          },
+        };
+      }
+      return {
+        valid: true,
+      };
+    }
+    return {
+      valid: false,
+      data: {
+        latestVersion: null,
+      },
+    };
+  }
+}

package/core-diagnoses/validate-git-exec.ts

@@ -0,0 +1,39 @@
+import execa from 'execa';
+import { getGitExecutablePath } from '@teambit/git.modules.git-executable';
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+
+export const DIAGNOSIS_NAME_VALIDATE_GIT_EXEC = 'validate git exec';
+export default class ValidateGitExec extends Diagnosis {
+  name = DIAGNOSIS_NAME_VALIDATE_GIT_EXEC;
+  description = 'validate that git executable found';
+  category = 'vendors';
+
+  _formatSymptoms(bareResult: ExamineBareResult): string {
+    const gitExecutablePath = bareResult?.data?.gitExecutablePath;
+    return `git executable not found (path '${gitExecutablePath}')`;
+  }
+
+  _formatManualTreat() {
+    return "please ensure that git is installed and/or git_path is configured correctly - 'bit config set git_path <GIT_PATH>'";
+  }
+
+  async _runExamine(): Promise<ExamineBareResult> {
+    const gitExecutablePath = getGitExecutablePath();
+    try {
+      await execa(gitExecutablePath, ['--version']);
+      return {
+        valid: true,
+      };
+    } catch {
+      // if (err.code === 'ENOENT') {
+      // }
+      return {
+        valid: false,
+        data: {
+          gitExecutablePath,
+        },
+      };
+    }
+  }
+}

package/core-diagnoses/validate-npm-exec.ts

@@ -0,0 +1,41 @@
+import execa from 'execa';
+import { logger } from '@teambit/legacy.logger';
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+
+export default class ValidateNpmExec extends Diagnosis {
+  name = 'validate npm exec';
+  description = 'validate that npm executable found';
+  category = 'vendors';
+
+  _formatSymptoms(): string {
+    return 'npm executable not found';
+  }
+
+  _formatManualTreat() {
+    return 'please ensure npm is installed';
+  }
+
+  async _runExamine(): Promise<ExamineBareResult> {
+    const npmVersion = await getNpmVersion();
+    if (npmVersion) {
+      return {
+        valid: true,
+      };
+    }
+    return {
+      valid: false,
+      data: {},
+    };
+  }
+}
+
+export async function getNpmVersion(): Promise<string | null | undefined> {
+  try {
+    const { stdout, stderr } = await execa('npm', ['--version']);
+    if (stdout && !stderr) return stdout;
+  } catch (err: any) {
+    logger.debugAndAddBreadCrumb('npm-client', `got an error when executing "npm --version". ${err.message}`);
+  }
+  return null;
+}

package/core-diagnoses/validate-scope-objects.ts

@@ -0,0 +1,83 @@
+import { loadConsumerIfExist } from '@teambit/legacy.consumer';
+import { loadScope } from '@teambit/legacy.scope';
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+import { getRemoteScope } from '../doctor-context';
+
+export const DIAGNOSIS_NAME = 'validate scope objects';
+
+type ComponentWithMissingHead = {
+  id: string;
+  head: string;
+};
+
+export default class ValidateScopeObjects extends Diagnosis {
+  name = DIAGNOSIS_NAME;
+  description = 'check if all components have their head version objects';
+  category = 'scope integrity';
+
+  _formatSymptoms(bareResult: ExamineBareResult): string {
+    if (!bareResult.data) throw new Error('ValidateScopeObjects, bareResult.data is missing');
+    const { componentsWithMissingHeads } = bareResult.data;
+    if (!componentsWithMissingHeads || componentsWithMissingHeads.length === 0) {
+      return 'No issues found';
+    }
+    return `the following components have missing head version objects:\n${componentsWithMissingHeads
+      .map((c: ComponentWithMissingHead) => `  ${c.id} (head: ${c.head})`)
+      .join('\n')}`;
+  }
+
+  _formatManualTreat() {
+    return 'The missing objects need to be restored from backups or re-exported from workspaces that have these components.';
+  }
+
+  async _runExamine(): Promise<ExamineBareResult> {
+    // Check if running against a remote scope
+    const remoteScope = getRemoteScope();
+    let scope = remoteScope;
+
+    // If not remote, try to get scope locally
+    if (!scope) {
+      // First try workspace
+      const consumer = await loadConsumerIfExist();
+      scope = consumer?.scope;
+
+      // If no workspace, try to load bare scope directly
+      if (!scope) {
+        try {
+          scope = await loadScope();
+        } catch {
+          // Not in a scope, that's fine
+          return { valid: true };
+        }
+      }
+    }
+
+    // Get all local components only
+    const modelComponents = await scope.list(true);
+    const componentsWithMissingHeads: ComponentWithMissingHead[] = [];
+
+    // Check each component
+    for (const modelComponent of modelComponents) {
+      const head = modelComponent.getHead();
+      if (!head) continue;
+
+      // Check if the head version object exists
+      const headVersion = await scope.objects.load(head, false);
+      if (!headVersion) {
+        componentsWithMissingHeads.push({
+          id: modelComponent.id(),
+          head: head.toString(),
+        });
+      }
+    }
+
+    return {
+      valid: componentsWithMissingHeads.length === 0,
+      data: {
+        componentsWithMissingHeads,
+        totalComponents: modelComponents.length,
+      },
+    };
+  }
+}

package/core-diagnoses/validate-workspace-bit-json-syntax.ts

@@ -0,0 +1,36 @@
+import { loadConsumer } from '@teambit/legacy.consumer';
+import { LegacyWorkspaceConfig } from '@teambit/legacy.consumer-config';
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+
+export default class ValidateWorkspaceBitJsonSyntax extends Diagnosis {
+  name = "validate workspace's bit config";
+  description = 'validate workspace configuration object';
+  category = 'configuration';
+
+  _formatSymptoms(bareResult: ExamineBareResult): string {
+    const bitJsonPath = bareResult?.data?.bitJsonPath;
+    return `invalid workspace.jsonc: ${bitJsonPath} is not a valid JSON file.`;
+  }
+
+  _formatManualTreat() {
+    return 'manually fix the workspace.jsonc or consider running bit init --reset to recreate the file';
+  }
+
+  // TODO: support configuration from package.json
+  async _runExamine(): Promise<ExamineBareResult> {
+    const consumer = await loadConsumer();
+    const consumerPath = consumer.getPath();
+    try {
+      await LegacyWorkspaceConfig.loadIfExist(consumerPath, consumer.scope.path);
+      return {
+        valid: true,
+      };
+    } catch {
+      return {
+        valid: false,
+        data: {},
+      };
+    }
+  }
+}

package/core-diagnoses/validate-yarn-exec.ts

@@ -0,0 +1,41 @@
+import execa from 'execa';
+import { logger } from '@teambit/legacy.logger';
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+
+export default class ValidateYarnExec extends Diagnosis {
+  name = 'validate yarn exec';
+  description = 'validate that yarn executable found';
+  category = 'vendors';
+
+  _formatSymptoms(): string {
+    return 'yarn executable not found';
+  }
+
+  _formatManualTreat() {
+    return 'please ensure yarn is installed';
+  }
+
+  async _runExamine(): Promise<ExamineBareResult> {
+    const yarnVersion = await getYarnVersion();
+    if (yarnVersion) {
+      return {
+        valid: true,
+      };
+    }
+    return {
+      valid: false,
+      data: {},
+    };
+  }
+}
+
+export async function getYarnVersion(): Promise<string | null | undefined> {
+  try {
+    const { stdout } = await execa('yarn', ['-v']);
+    return stdout;
+  } catch (e: any) {
+    logger.debugAndAddBreadCrumb('npm-client', `can't find yarn version by running yarn -v. ${e.message}`);
+  }
+  return null;
+}

package/dist/core-diagnoses/broken-symlink-files.d.ts

@@ -0,0 +1,16 @@
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+export declare const DIAGNOSIS_NAME = "check environment symlinks";
+export default class BrokenSymlinkFiles extends Diagnosis {
+    name: string;
+    description: string;
+    category: string;
+    _formatSymptoms(bareResult: ExamineBareResult): string;
+    _formatManualTreat(bareResult: ExamineBareResult): string;
+    _runExamine(): Promise<ExamineBareResult>;
+    _getLinkIfExist(symlinkPath: string): Promise<string | null | undefined>;
+    /**
+     * deleting the environment directory causes Bit to reinstall it next time
+     */
+    _getPathToDelete(symlinkPath: string): string;
+}

package/dist/core-diagnoses/broken-symlink-files.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.DIAGNOSIS_NAME = void 0;
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _glob() {
+  const data = require("glob");
+  _glob = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.consumer");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.scope");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnosis() {
+  const data = _interopRequireDefault(require("../diagnosis"));
+  _diagnosis = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: 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); }
+const DIAGNOSIS_NAME = exports.DIAGNOSIS_NAME = 'check environment symlinks';
+class BrokenSymlinkFiles extends _diagnosis().default {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", DIAGNOSIS_NAME);
+    _defineProperty(this, "description", 'validate generated symlinks for workspace environments');
+    _defineProperty(this, "category", 'local environments');
+  }
+  _formatSymptoms(bareResult) {
+    if (!bareResult.data) throw new Error('BrokenSymlinkFiles, bareResult.data is missing');
+    const toString = bareResult.data.brokenSymlinks.map(brokenSymlink => `symlink path: "${brokenSymlink.symlinkPath}", broken link: "${brokenSymlink.brokenPath}"`).join('\n');
+    return `the following symlinks points to non-existing paths\n${toString}`;
+  }
+  _formatManualTreat(bareResult) {
+    if (!bareResult.data) throw new Error('BrokenSymlinkFiles, bareResult.data is missing');
+    const toString = (0, _lodash().uniq)(bareResult.data.brokenSymlinks.map(b => b.pathToDelete)).join('\n');
+    return `please delete the following paths:\n${toString}`;
+  }
+  async _runExamine() {
+    const consumer = await (0, _legacy().loadConsumer)();
+    const envComponentsDir = _path().default.join(consumer.scope.getPath(), _legacy2().Scope.getComponentsRelativePath());
+    const potentialSymlinks = (0, _glob().globSync)('**/node_modules/@bit/**', {
+      cwd: envComponentsDir
+    });
+    const potentialSymlinksAbs = potentialSymlinks.map(p => _path().default.join(envComponentsDir, p));
+    const brokenSymlinks = [];
+    const results = potentialSymlinksAbs.map(async potentialSymlink => {
+      const link = await this._getLinkIfExist(potentialSymlink);
+      if (!link) return;
+      const exists = await _fsExtra().default.pathExists(link);
+      if (exists) return;
+      const brokenSymlink = {
+        symlinkPath: potentialSymlink,
+        brokenPath: link,
+        pathToDelete: this._getPathToDelete(potentialSymlink)
+      };
+      brokenSymlinks.push(brokenSymlink);
+    });
+    await Promise.all(results);
+    return {
+      valid: brokenSymlinks.length === 0,
+      data: {
+        brokenSymlinks
+      }
+    };
+  }
+  async _getLinkIfExist(symlinkPath) {
+    try {
+      const link = await _fsExtra().default.readlink(symlinkPath);
+      return link;
+    } catch {
+      // probably not a symlink
+      return null;
+    }
+  }
+
+  /**
+   * deleting the environment directory causes Bit to reinstall it next time
+   */
+  _getPathToDelete(symlinkPath) {
+    const envDirectory = symlinkPath.split(_path().default.join('node_modules', '@bit'))[0];
+    return envDirectory.slice(0, -1); // remove the last slash
+  }
+}
+exports.default = BrokenSymlinkFiles;
+
+//# sourceMappingURL=broken-symlink-files.js.map

package/dist/core-diagnoses/broken-symlink-files.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_fsExtra","data","_interopRequireDefault","require","_glob","_path","_legacy","_legacy2","_diagnosis","_lodash","e","__esModule","default","_defineProperty","r","t","_toPropertyKey","Object","defineProperty","value","enumerable","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","DIAGNOSIS_NAME","exports","BrokenSymlinkFiles","Diagnosis","constructor","args","_formatSymptoms","bareResult","Error","toString","brokenSymlinks","map","brokenSymlink","symlinkPath","brokenPath","join","_formatManualTreat","uniq","b","pathToDelete","_runExamine","consumer","loadConsumer","envComponentsDir","path","scope","getPath","Scope","getComponentsRelativePath","potentialSymlinks","globSync","cwd","potentialSymlinksAbs","p","results","potentialSymlink","link","_getLinkIfExist","exists","fs","pathExists","_getPathToDelete","push","Promise","all","valid","length","readlink","envDirectory","split","slice"],"sources":["broken-symlink-files.ts"],"sourcesContent":["import fs from 'fs-extra';\nimport { globSync } from 'glob';\nimport path from 'path';\nimport { loadConsumer } from '@teambit/legacy.consumer';\nimport { Scope } from '@teambit/legacy.scope';\nimport type { ExamineBareResult } from '../diagnosis';\nimport Diagnosis from '../diagnosis';\nimport { uniq } from 'lodash';\n\ntype BrokenSymlink = { symlinkPath: string; brokenPath: string; pathToDelete: string };\nexport const DIAGNOSIS_NAME = 'check environment symlinks';\n\nexport default class BrokenSymlinkFiles extends Diagnosis {\n  name = DIAGNOSIS_NAME;\n  description = 'validate generated symlinks for workspace environments';\n  category = 'local environments';\n\n  _formatSymptoms(bareResult: ExamineBareResult): string {\n    if (!bareResult.data) throw new Error('BrokenSymlinkFiles, bareResult.data is missing');\n    const toString = bareResult.data.brokenSymlinks\n      .map(\n        (brokenSymlink) => `symlink path: \"${brokenSymlink.symlinkPath}\", broken link: \"${brokenSymlink.brokenPath}\"`\n      )\n      .join('\\n');\n    return `the following symlinks points to non-existing paths\\n${toString}`;\n  }\n\n  _formatManualTreat(bareResult: ExamineBareResult) {\n    if (!bareResult.data) throw new Error('BrokenSymlinkFiles, bareResult.data is missing');\n    const toString = uniq(bareResult.data.brokenSymlinks.map((b) => b.pathToDelete)).join('\\n');\n    return `please delete the following paths:\\n${toString}`;\n  }\n\n  async _runExamine(): Promise<ExamineBareResult> {\n    const consumer = await loadConsumer();\n    const envComponentsDir = path.join(consumer.scope.getPath(), Scope.getComponentsRelativePath());\n    const potentialSymlinks = globSync('**/node_modules/@bit/**', { cwd: envComponentsDir });\n    const potentialSymlinksAbs = potentialSymlinks.map((p) => path.join(envComponentsDir, p));\n    const brokenSymlinks: BrokenSymlink[] = [];\n    const results = potentialSymlinksAbs.map(async (potentialSymlink) => {\n      const link = await this._getLinkIfExist(potentialSymlink);\n      if (!link) return;\n      const exists = await fs.pathExists(link);\n      if (exists) return;\n      const brokenSymlink = {\n        symlinkPath: potentialSymlink,\n        brokenPath: link,\n        pathToDelete: this._getPathToDelete(potentialSymlink),\n      };\n      brokenSymlinks.push(brokenSymlink);\n    });\n    await Promise.all(results);\n    return {\n      valid: brokenSymlinks.length === 0,\n      data: {\n        brokenSymlinks,\n      },\n    };\n  }\n\n  async _getLinkIfExist(symlinkPath: string): Promise<string | null | undefined> {\n    try {\n      const link = await fs.readlink(symlinkPath);\n      return link;\n    } catch {\n      // probably not a symlink\n      return null;\n    }\n  }\n\n  /**\n   * deleting the environment directory causes Bit to reinstall it next time\n   */\n  _getPathToDelete(symlinkPath: string): string {\n    const envDirectory = symlinkPath.split(path.join('node_modules', '@bit'))[0];\n    return envDirectory.slice(0, -1); // remove the last slash\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/core-diagnoses/orphan-symlink-objects.d.ts

@@ -0,0 +1,11 @@
+import type { ExamineBareResult } from '../diagnosis';
+import Diagnosis from '../diagnosis';
+export declare const DIAGNOSIS_NAME = "check orphan refs";
+export default class OrphanSymlinkObjects extends Diagnosis {
+    name: string;
+    description: string;
+    category: string;
+    _formatSymptoms(bareResult: ExamineBareResult): string;
+    _formatManualTreat(bareResult: ExamineBareResult): string;
+    _runExamine(): Promise<ExamineBareResult>;
+}