@sanity/cli 6.0.0-alpha.8 → 6.0.0

package/dist/util/packageManager/installationInfo/detectPackages.js

@@ -0,0 +1,190 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { resolve as resolveImport } from 'import-meta-resolve';
+import { readJsonFile } from './readJsonFile.js';
+import { resolveVersionRange } from './resolveVersionRange.js';
+/**
+ * Finds where a package is declared in the workspace, walking up from startDir.
+ * Resolves catalog: protocol if used.
+ */ export async function findPackageDeclaration(packageName, startDir, workspaceInfo) {
+    let currentDir = path.resolve(startDir);
+    const fsRoot = path.parse(currentDir).root;
+    // Walk up until we pass the workspace root
+    while(currentDir !== fsRoot){
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        const packageJson = await readJsonFile(packageJsonPath);
+        if (packageJson) {
+            // Check dependencies and devDependencies only.
+            // peerDependencies are excluded because they are not auto-installed —
+            // flagging them as declared-not-installed would be a false positive
+            // (common in Sanity plugins that list sanity as a peer dep).
+            const depTypes = [
+                'dependencies',
+                'devDependencies'
+            ];
+            for (const depType of depTypes){
+                const deps = packageJson[depType];
+                if (deps && packageName in deps) {
+                    const declaredVersionRange = deps[packageName];
+                    const versionRange = await resolveVersionRange(declaredVersionRange, packageName, workspaceInfo);
+                    return {
+                        declaredVersionRange,
+                        dependencyType: depType,
+                        packageJsonPath,
+                        versionRange
+                    };
+                }
+            }
+        }
+        // Stop at workspace root
+        if (currentDir === workspaceInfo.root) {
+            break;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+/**
+ * Finds if a package has an override/resolution defined in the workspace root.
+ * Checks npm overrides, yarn resolutions, and pnpm overrides.
+ */ export async function findPackageOverride(packageName, workspaceInfo) {
+    const rootPackageJsonPath = path.join(workspaceInfo.root, 'package.json');
+    const packageJson = await readJsonFile(rootPackageJsonPath);
+    if (!packageJson) {
+        return null;
+    }
+    // Check npm/pnpm overrides
+    if (packageJson.overrides && packageName in packageJson.overrides) {
+        return {
+            mechanism: 'npm-overrides',
+            packageJsonPath: rootPackageJsonPath,
+            versionRange: packageJson.overrides[packageName]
+        };
+    }
+    // Check pnpm.overrides (alternative location)
+    if (packageJson.pnpm?.overrides && packageName in packageJson.pnpm.overrides) {
+        return {
+            mechanism: 'pnpm-overrides',
+            packageJsonPath: rootPackageJsonPath,
+            versionRange: packageJson.pnpm.overrides[packageName]
+        };
+    }
+    // Check yarn resolutions
+    if (packageJson.resolutions && packageName in packageJson.resolutions) {
+        return {
+            mechanism: 'yarn-resolutions',
+            packageJsonPath: rootPackageJsonPath,
+            versionRange: packageJson.resolutions[packageName]
+        };
+    }
+    return null;
+}
+/**
+ * Finds installed package in node_modules, walking up from startDir.
+ * Also extracts \@sanity/cli dependency range from sanity package if applicable.
+ *
+ * Handles both hoisted (npm/yarn) and nested (pnpm) node_modules structures.
+ */ export async function findInstalledPackage(packageName, startDir, workspaceRoot) {
+    let currentDir = path.resolve(startDir);
+    const fsRoot = path.parse(currentDir).root;
+    while(currentDir !== fsRoot){
+        // First, check the top-level node_modules (works for npm, yarn, and hoisted pnpm)
+        const result = await findPackageInNodeModules(packageName, path.join(currentDir, 'node_modules'));
+        if (result) {
+            return result;
+        }
+        // For @sanity/cli, use Node's module resolution from sanity's location.
+        // This handles all package manager layouts (pnpm nested deps, hoisting, etc.)
+        if (packageName === '@sanity/cli') {
+            const sanityPath = await resolvePackagePath(path.join(currentDir, 'node_modules', 'sanity'));
+            if (sanityPath) {
+                const nestedResult = await resolveCliFromSanity(sanityPath);
+                if (nestedResult) {
+                    return nestedResult;
+                }
+            }
+        }
+        // Stop at workspace root
+        if (currentDir === workspaceRoot) {
+            break;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+/**
+ * Looks for a package in a specific node_modules directory.
+ */ async function findPackageInNodeModules(packageName, nodeModulesDir) {
+    const packagePath = path.join(nodeModulesDir, packageName);
+    const resolvedPath = await resolvePackagePath(packagePath);
+    if (!resolvedPath) {
+        return null;
+    }
+    const packageJsonPath = path.join(resolvedPath, 'package.json');
+    const packageJson = await readJsonFile(packageJsonPath);
+    if (!packageJson?.version) {
+        return null;
+    }
+    let cliDependencyRange = null;
+    // If this is the sanity package, extract @sanity/cli dependency
+    if (packageName === 'sanity') {
+        cliDependencyRange = packageJson.dependencies?.['@sanity/cli'] ?? null;
+    }
+    return {
+        cliDependencyRange,
+        path: resolvedPath,
+        version: packageJson.version
+    };
+}
+/**
+ * Resolves a package path, following symlinks (pnpm uses symlinks).
+ * Returns null if the path doesn't exist.
+ */ async function resolvePackagePath(packagePath) {
+    try {
+        // Use realpath to follow symlinks (important for pnpm)
+        return await fs.realpath(packagePath);
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Uses Node's module resolution to find \@sanity/cli from sanity's location.
+ * This is more robust than manually traversing directories as it handles
+ * all package manager layouts (pnpm nested deps, hoisting variations, etc.)
+ */ async function resolveCliFromSanity(sanityPath) {
+    try {
+        // Resolve @sanity/cli/package.json from sanity's perspective
+        const sanityPkgUrl = pathToFileURL(path.join(sanityPath, 'package.json')).href;
+        const cliPkgUrl = resolveImport('@sanity/cli/package.json', sanityPkgUrl);
+        const cliPkgPath = fileURLToPath(cliPkgUrl);
+        const cliPath = path.dirname(cliPkgPath);
+        const packageJson = await readJsonFile(cliPkgPath);
+        if (!packageJson?.version) {
+            return null;
+        }
+        return {
+            cliDependencyRange: null,
+            path: cliPath,
+            version: packageJson.version
+        };
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Collects all package info (declaration, override, installed) for a package.
+ */ export async function collectPackageInfo(packageName, startDir, workspaceInfo) {
+    const [declared, override, installed] = await Promise.all([
+        findPackageDeclaration(packageName, startDir, workspaceInfo),
+        findPackageOverride(packageName, workspaceInfo),
+        findInstalledPackage(packageName, startDir, workspaceInfo.root)
+    ]);
+    return {
+        declared,
+        installed,
+        override
+    };
+}
+
+//# sourceMappingURL=detectPackages.js.map

package/dist/util/packageManager/installationInfo/detectPackages.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/util/packageManager/installationInfo/detectPackages.ts"],"sourcesContent":["import fs from 'node:fs/promises'\nimport path from 'node:path'\nimport {fileURLToPath, pathToFileURL} from 'node:url'\n\nimport {resolve as resolveImport} from 'import-meta-resolve'\n\nimport {readJsonFile} from './readJsonFile.js'\nimport {resolveVersionRange} from './resolveVersionRange.js'\nimport {\n  type InstalledPackage,\n  type PackageDeclaration,\n  type PackageInfo,\n  type PackageOverride,\n  type SanityPackage,\n  type WorkspaceInfo,\n} from './types.js'\n\ninterface PackageJson {\n  dependencies?: Record<string, string>\n  devDependencies?: Record<string, string>\n  name?: string\n  overrides?: Record<string, string>\n  pnpm?: {\n    overrides?: Record<string, string>\n  }\n  resolutions?: Record<string, string>\n  version?: string\n}\n\n/**\n * Finds where a package is declared in the workspace, walking up from startDir.\n * Resolves catalog: protocol if used.\n */\nexport async function findPackageDeclaration(\n  packageName: SanityPackage,\n  startDir: string,\n  workspaceInfo: WorkspaceInfo,\n): Promise<PackageDeclaration | null> {\n  let currentDir = path.resolve(startDir)\n  const fsRoot = path.parse(currentDir).root\n\n  // Walk up until we pass the workspace root\n  while (currentDir !== fsRoot) {\n    const packageJsonPath = path.join(currentDir, 'package.json')\n    const packageJson = await readJsonFile<PackageJson>(packageJsonPath)\n\n    if (packageJson) {\n      // Check dependencies and devDependencies only.\n      // peerDependencies are excluded because they are not auto-installed —\n      // flagging them as declared-not-installed would be a false positive\n      // (common in Sanity plugins that list sanity as a peer dep).\n      const depTypes = ['dependencies', 'devDependencies'] as const\n      for (const depType of depTypes) {\n        const deps = packageJson[depType]\n        if (deps && packageName in deps) {\n          const declaredVersionRange = deps[packageName]\n          const versionRange = await resolveVersionRange(\n            declaredVersionRange,\n            packageName,\n            workspaceInfo,\n          )\n\n          return {\n            declaredVersionRange,\n            dependencyType: depType,\n            packageJsonPath,\n            versionRange,\n          }\n        }\n      }\n    }\n\n    // Stop at workspace root\n    if (currentDir === workspaceInfo.root) {\n      break\n    }\n\n    currentDir = path.dirname(currentDir)\n  }\n\n  return null\n}\n\n/**\n * Finds if a package has an override/resolution defined in the workspace root.\n * Checks npm overrides, yarn resolutions, and pnpm overrides.\n */\nexport async function findPackageOverride(\n  packageName: SanityPackage,\n  workspaceInfo: WorkspaceInfo,\n): Promise<PackageOverride | null> {\n  const rootPackageJsonPath = path.join(workspaceInfo.root, 'package.json')\n  const packageJson = await readJsonFile<PackageJson>(rootPackageJsonPath)\n\n  if (!packageJson) {\n    return null\n  }\n\n  // Check npm/pnpm overrides\n  if (packageJson.overrides && packageName in packageJson.overrides) {\n    return {\n      mechanism: 'npm-overrides',\n      packageJsonPath: rootPackageJsonPath,\n      versionRange: packageJson.overrides[packageName],\n    }\n  }\n\n  // Check pnpm.overrides (alternative location)\n  if (packageJson.pnpm?.overrides && packageName in packageJson.pnpm.overrides) {\n    return {\n      mechanism: 'pnpm-overrides',\n      packageJsonPath: rootPackageJsonPath,\n      versionRange: packageJson.pnpm.overrides[packageName],\n    }\n  }\n\n  // Check yarn resolutions\n  if (packageJson.resolutions && packageName in packageJson.resolutions) {\n    return {\n      mechanism: 'yarn-resolutions',\n      packageJsonPath: rootPackageJsonPath,\n      versionRange: packageJson.resolutions[packageName],\n    }\n  }\n\n  return null\n}\n\n/**\n * Finds installed package in node_modules, walking up from startDir.\n * Also extracts \\@sanity/cli dependency range from sanity package if applicable.\n *\n * Handles both hoisted (npm/yarn) and nested (pnpm) node_modules structures.\n */\nexport async function findInstalledPackage(\n  packageName: SanityPackage,\n  startDir: string,\n  workspaceRoot: string,\n): Promise<InstalledPackage | null> {\n  let currentDir = path.resolve(startDir)\n  const fsRoot = path.parse(currentDir).root\n\n  while (currentDir !== fsRoot) {\n    // First, check the top-level node_modules (works for npm, yarn, and hoisted pnpm)\n    const result = await findPackageInNodeModules(\n      packageName,\n      path.join(currentDir, 'node_modules'),\n    )\n    if (result) {\n      return result\n    }\n\n    // For @sanity/cli, use Node's module resolution from sanity's location.\n    // This handles all package manager layouts (pnpm nested deps, hoisting, etc.)\n    if (packageName === '@sanity/cli') {\n      const sanityPath = await resolvePackagePath(path.join(currentDir, 'node_modules', 'sanity'))\n      if (sanityPath) {\n        const nestedResult = await resolveCliFromSanity(sanityPath)\n        if (nestedResult) {\n          return nestedResult\n        }\n      }\n    }\n\n    // Stop at workspace root\n    if (currentDir === workspaceRoot) {\n      break\n    }\n\n    currentDir = path.dirname(currentDir)\n  }\n\n  return null\n}\n\n/**\n * Looks for a package in a specific node_modules directory.\n */\nasync function findPackageInNodeModules(\n  packageName: SanityPackage,\n  nodeModulesDir: string,\n): Promise<InstalledPackage | null> {\n  const packagePath = path.join(nodeModulesDir, packageName)\n  const resolvedPath = await resolvePackagePath(packagePath)\n\n  if (!resolvedPath) {\n    return null\n  }\n\n  const packageJsonPath = path.join(resolvedPath, 'package.json')\n  const packageJson = await readJsonFile<PackageJson>(packageJsonPath)\n\n  if (!packageJson?.version) {\n    return null\n  }\n\n  let cliDependencyRange: string | null = null\n\n  // If this is the sanity package, extract @sanity/cli dependency\n  if (packageName === 'sanity') {\n    cliDependencyRange = packageJson.dependencies?.['@sanity/cli'] ?? null\n  }\n\n  return {\n    cliDependencyRange,\n    path: resolvedPath,\n    version: packageJson.version,\n  }\n}\n\n/**\n * Resolves a package path, following symlinks (pnpm uses symlinks).\n * Returns null if the path doesn't exist.\n */\nasync function resolvePackagePath(packagePath: string): Promise<string | null> {\n  try {\n    // Use realpath to follow symlinks (important for pnpm)\n    return await fs.realpath(packagePath)\n  } catch {\n    return null\n  }\n}\n\n/**\n * Uses Node's module resolution to find \\@sanity/cli from sanity's location.\n * This is more robust than manually traversing directories as it handles\n * all package manager layouts (pnpm nested deps, hoisting variations, etc.)\n */\nasync function resolveCliFromSanity(sanityPath: string): Promise<InstalledPackage | null> {\n  try {\n    // Resolve @sanity/cli/package.json from sanity's perspective\n    const sanityPkgUrl = pathToFileURL(path.join(sanityPath, 'package.json')).href\n    const cliPkgUrl = resolveImport('@sanity/cli/package.json', sanityPkgUrl)\n    const cliPkgPath = fileURLToPath(cliPkgUrl)\n    const cliPath = path.dirname(cliPkgPath)\n\n    const packageJson = await readJsonFile<PackageJson>(cliPkgPath)\n    if (!packageJson?.version) {\n      return null\n    }\n\n    return {\n      cliDependencyRange: null,\n      path: cliPath,\n      version: packageJson.version,\n    }\n  } catch {\n    return null\n  }\n}\n\n/**\n * Collects all package info (declaration, override, installed) for a package.\n */\nexport async function collectPackageInfo(\n  packageName: SanityPackage,\n  startDir: string,\n  workspaceInfo: WorkspaceInfo,\n): Promise<PackageInfo> {\n  const [declared, override, installed] = await Promise.all([\n    findPackageDeclaration(packageName, startDir, workspaceInfo),\n    findPackageOverride(packageName, workspaceInfo),\n    findInstalledPackage(packageName, startDir, workspaceInfo.root),\n  ])\n\n  return {declared, installed, override}\n}\n"],"names":["fs","path","fileURLToPath","pathToFileURL","resolve","resolveImport","readJsonFile","resolveVersionRange","findPackageDeclaration","packageName","startDir","workspaceInfo","currentDir","fsRoot","parse","root","packageJsonPath","join","packageJson","depTypes","depType","deps","declaredVersionRange","versionRange","dependencyType","dirname","findPackageOverride","rootPackageJsonPath","overrides","mechanism","pnpm","resolutions","findInstalledPackage","workspaceRoot","result","findPackageInNodeModules","sanityPath","resolvePackagePath","nestedResult","resolveCliFromSanity","nodeModulesDir","packagePath","resolvedPath","version","cliDependencyRange","dependencies","realpath","sanityPkgUrl","href","cliPkgUrl","cliPkgPath","cliPath","collectPackageInfo","declared","override","installed","Promise","all"],"mappings":"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"}

package/dist/util/packageManager/installationInfo/detectWorkspace.js

@@ -0,0 +1,192 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { readJsonFile } from './readJsonFile.js';
+const LOCKFILE_MAP = {
+    'bun.lock': 'bun',
+    'bun.lockb': 'bun',
+    'package-lock.json': 'npm',
+    'pnpm-lock.yaml': 'pnpm',
+    'yarn.lock': 'yarn'
+};
+// Explicit detection order: determines which lockfile is preferred when multiple exist.
+// pnpm > npm > yarn > bun — pnpm first because it's most common in Sanity projects.
+const LOCKFILE_NAMES = [
+    'pnpm-lock.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'bun.lock',
+    'bun.lockb'
+];
+/**
+ * Detects workspace configuration by walking up from the given directory.
+ * Identifies workspace type, root, lockfile, and whether multiple lockfiles exist.
+ *
+ * The search stops when a lockfile is found, as this indicates a project root.
+ * This prevents accidentally detecting parent monorepo configurations when
+ * analyzing a standalone project.
+ */ export async function detectWorkspace(cwd) {
+    const nearestPackageJson = await findNearestPackageJson(cwd);
+    if (!nearestPackageJson) {
+        // No package.json found - return minimal info
+        return {
+            bunfig: false,
+            hasMultipleLockfiles: false,
+            lockfile: null,
+            nearestPackageJson: null,
+            root: cwd,
+            type: 'standalone',
+            yarnBerry: false
+        };
+    }
+    // Find workspace root and type by walking up
+    // This also finds lockfiles along the way
+    const { lockfiles, root, type } = await findWorkspaceRoot(path.dirname(nearestPackageJson));
+    // De-duplicate by package manager type: bun.lock + bun.lockb both map to 'bun'
+    // and should not trigger a false "multiple lockfiles" warning.
+    const uniquePmTypes = new Set(lockfiles.map((l)=>l.type));
+    const hasMultipleLockfiles = uniquePmTypes.size > 1;
+    // Use the first lockfile found (ordered by LOCKFILE_NAMES priority)
+    const lockfile = lockfiles.length > 0 ? lockfiles[0] : null;
+    // PM-specific config files that exist even in standalone (non-workspace) projects
+    const [yarnBerry, bunfig] = await Promise.all([
+        fileExists(path.join(root, '.yarnrc.yml')),
+        fileExists(path.join(root, 'bunfig.toml'))
+    ]);
+    return {
+        bunfig,
+        hasMultipleLockfiles,
+        lockfile,
+        nearestPackageJson,
+        root,
+        type,
+        yarnBerry
+    };
+}
+async function findNearestPackageJson(startDir) {
+    let currentDir = path.resolve(startDir);
+    const root = path.parse(currentDir).root;
+    // Intentionally stops before the filesystem root (/) to avoid false positives
+    // from system-level package.json files. This is consistent across all three
+    // walking functions (findNearestPackageJson, findWorkspaceRoot, findInstalledPackage).
+    while(currentDir !== root){
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (await fileExists(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+async function findWorkspaceRoot(startDir) {
+    let currentDir = path.resolve(startDir);
+    const fsRoot = path.parse(currentDir).root;
+    while(currentDir !== fsRoot){
+        // Check for lockfiles at this level - if found, this is the project root
+        const lockfiles = await findLockfiles(currentDir);
+        if (lockfiles.length > 0) {
+            // Found lockfile(s), this is the project root
+            // Now determine workspace type
+            // Check for pnpm-workspace.yaml (definitive pnpm workspace marker)
+            const pnpmWorkspacePath = path.join(currentDir, 'pnpm-workspace.yaml');
+            if (await fileExists(pnpmWorkspacePath)) {
+                return {
+                    lockfiles,
+                    root: currentDir,
+                    type: 'pnpm-workspaces'
+                };
+            }
+            // Check for package.json with workspaces field
+            const packageJson = await readJsonFile(path.join(currentDir, 'package.json'));
+            if (packageJson?.workspaces) {
+                return {
+                    lockfiles,
+                    root: currentDir,
+                    type: getWorkspaceType(lockfiles)
+                };
+            }
+            // Has lockfile but no workspace config - standalone project
+            return {
+                lockfiles,
+                root: currentDir,
+                type: 'standalone'
+            };
+        }
+        // No lockfile at this level, check for workspace markers before going up.
+        // This handles the case where we're in a nested package that doesn't have
+        // its own lockfile, or a fresh checkout before `install` has been run.
+        // We already know lockfiles is [] for this dir, so don't re-query.
+        // Check for pnpm-workspace.yaml
+        const pnpmWorkspacePath = path.join(currentDir, 'pnpm-workspace.yaml');
+        if (await fileExists(pnpmWorkspacePath)) {
+            return {
+                lockfiles: [],
+                root: currentDir,
+                type: 'pnpm-workspaces'
+            };
+        }
+        // Check for package.json with workspaces field
+        const packageJson = await readJsonFile(path.join(currentDir, 'package.json'));
+        if (packageJson?.workspaces) {
+            // Without a lockfile we can't determine the workspace type from
+            // lockfile presence. Check for PM-specific config files to
+            // distinguish the workspace type before falling back to npm-workspaces.
+            if (await fileExists(path.join(currentDir, '.yarnrc.yml'))) {
+                return {
+                    lockfiles: [],
+                    root: currentDir,
+                    type: 'yarn-workspaces'
+                };
+            }
+            if (await fileExists(path.join(currentDir, 'bunfig.toml'))) {
+                return {
+                    lockfiles: [],
+                    root: currentDir,
+                    type: 'bun-workspaces'
+                };
+            }
+            return {
+                lockfiles: [],
+                root: currentDir,
+                type: 'npm-workspaces'
+            };
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    // No workspace or lockfile found, use the starting directory as root
+    return {
+        lockfiles: [],
+        root: startDir,
+        type: 'standalone'
+    };
+}
+/**
+ * Determines the workspace type from the lockfiles found at the workspace root.
+ * Uses the same priority order as LOCKFILE_NAMES (pnpm, npm, yarn, bun)
+ * so that workspace.type and workspace.lockfile.type always agree.
+ */ function getWorkspaceType(lockfiles) {
+    if (lockfiles.some((l)=>l.type === 'pnpm')) return 'pnpm-workspaces';
+    if (lockfiles.some((l)=>l.type === 'npm')) return 'npm-workspaces';
+    if (lockfiles.some((l)=>l.type === 'yarn')) return 'yarn-workspaces';
+    if (lockfiles.some((l)=>l.type === 'bun')) return 'bun-workspaces';
+    return 'npm-workspaces';
+}
+async function findLockfiles(dir) {
+    const results = await Promise.all(LOCKFILE_NAMES.map(async (name)=>{
+        const lockfilePath = path.join(dir, name);
+        return await fileExists(lockfilePath) ? {
+            path: lockfilePath,
+            type: LOCKFILE_MAP[name]
+        } : null;
+    }));
+    return results.filter((r)=>r !== null);
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=detectWorkspace.js.map

package/dist/util/packageManager/installationInfo/detectWorkspace.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/util/packageManager/installationInfo/detectWorkspace.ts"],"sourcesContent":["import fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport {readJsonFile} from './readJsonFile.js'\nimport {type LockfileType, type WorkspaceInfo, type WorkspaceType} from './types.js'\n\ninterface LockfileInfo {\n  path: string\n  type: LockfileType\n}\n\nconst LOCKFILE_MAP: Record<string, LockfileType> = {\n  'bun.lock': 'bun',\n  'bun.lockb': 'bun',\n  'package-lock.json': 'npm',\n  'pnpm-lock.yaml': 'pnpm',\n  'yarn.lock': 'yarn',\n}\n\n// Explicit detection order: determines which lockfile is preferred when multiple exist.\n// pnpm > npm > yarn > bun — pnpm first because it's most common in Sanity projects.\nconst LOCKFILE_NAMES = ['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock', 'bun.lock', 'bun.lockb']\n\n/**\n * Detects workspace configuration by walking up from the given directory.\n * Identifies workspace type, root, lockfile, and whether multiple lockfiles exist.\n *\n * The search stops when a lockfile is found, as this indicates a project root.\n * This prevents accidentally detecting parent monorepo configurations when\n * analyzing a standalone project.\n */\nexport async function detectWorkspace(cwd: string): Promise<WorkspaceInfo> {\n  const nearestPackageJson = await findNearestPackageJson(cwd)\n  if (!nearestPackageJson) {\n    // No package.json found - return minimal info\n    return {\n      bunfig: false,\n      hasMultipleLockfiles: false,\n      lockfile: null,\n      nearestPackageJson: null,\n      root: cwd,\n      type: 'standalone',\n      yarnBerry: false,\n    }\n  }\n\n  // Find workspace root and type by walking up\n  // This also finds lockfiles along the way\n  const {lockfiles, root, type} = await findWorkspaceRoot(path.dirname(nearestPackageJson))\n\n  // De-duplicate by package manager type: bun.lock + bun.lockb both map to 'bun'\n  // and should not trigger a false \"multiple lockfiles\" warning.\n  const uniquePmTypes = new Set(lockfiles.map((l) => l.type))\n  const hasMultipleLockfiles = uniquePmTypes.size > 1\n\n  // Use the first lockfile found (ordered by LOCKFILE_NAMES priority)\n  const lockfile = lockfiles.length > 0 ? lockfiles[0] : null\n\n  // PM-specific config files that exist even in standalone (non-workspace) projects\n  const [yarnBerry, bunfig] = await Promise.all([\n    fileExists(path.join(root, '.yarnrc.yml')),\n    fileExists(path.join(root, 'bunfig.toml')),\n  ])\n\n  return {\n    bunfig,\n    hasMultipleLockfiles,\n    lockfile,\n    nearestPackageJson,\n    root,\n    type,\n    yarnBerry,\n  }\n}\n\nasync function findNearestPackageJson(startDir: string): Promise<string | null> {\n  let currentDir = path.resolve(startDir)\n  const root = path.parse(currentDir).root\n\n  // Intentionally stops before the filesystem root (/) to avoid false positives\n  // from system-level package.json files. This is consistent across all three\n  // walking functions (findNearestPackageJson, findWorkspaceRoot, findInstalledPackage).\n  while (currentDir !== root) {\n    const packageJsonPath = path.join(currentDir, 'package.json')\n    if (await fileExists(packageJsonPath)) {\n      return packageJsonPath\n    }\n    currentDir = path.dirname(currentDir)\n  }\n\n  return null\n}\n\nasync function findWorkspaceRoot(\n  startDir: string,\n): Promise<{lockfiles: LockfileInfo[]; root: string; type: WorkspaceType}> {\n  let currentDir = path.resolve(startDir)\n  const fsRoot = path.parse(currentDir).root\n\n  while (currentDir !== fsRoot) {\n    // Check for lockfiles at this level - if found, this is the project root\n    const lockfiles = await findLockfiles(currentDir)\n\n    if (lockfiles.length > 0) {\n      // Found lockfile(s), this is the project root\n      // Now determine workspace type\n\n      // Check for pnpm-workspace.yaml (definitive pnpm workspace marker)\n      const pnpmWorkspacePath = path.join(currentDir, 'pnpm-workspace.yaml')\n      if (await fileExists(pnpmWorkspacePath)) {\n        return {lockfiles, root: currentDir, type: 'pnpm-workspaces'}\n      }\n\n      // Check for package.json with workspaces field\n      const packageJson = await readJsonFile(path.join(currentDir, 'package.json'))\n      if (packageJson?.workspaces) {\n        return {lockfiles, root: currentDir, type: getWorkspaceType(lockfiles)}\n      }\n\n      // Has lockfile but no workspace config - standalone project\n      return {lockfiles, root: currentDir, type: 'standalone'}\n    }\n\n    // No lockfile at this level, check for workspace markers before going up.\n    // This handles the case where we're in a nested package that doesn't have\n    // its own lockfile, or a fresh checkout before `install` has been run.\n    // We already know lockfiles is [] for this dir, so don't re-query.\n\n    // Check for pnpm-workspace.yaml\n    const pnpmWorkspacePath = path.join(currentDir, 'pnpm-workspace.yaml')\n    if (await fileExists(pnpmWorkspacePath)) {\n      return {lockfiles: [], root: currentDir, type: 'pnpm-workspaces'}\n    }\n\n    // Check for package.json with workspaces field\n    const packageJson = await readJsonFile(path.join(currentDir, 'package.json'))\n    if (packageJson?.workspaces) {\n      // Without a lockfile we can't determine the workspace type from\n      // lockfile presence. Check for PM-specific config files to\n      // distinguish the workspace type before falling back to npm-workspaces.\n      if (await fileExists(path.join(currentDir, '.yarnrc.yml'))) {\n        return {lockfiles: [], root: currentDir, type: 'yarn-workspaces'}\n      }\n      if (await fileExists(path.join(currentDir, 'bunfig.toml'))) {\n        return {lockfiles: [], root: currentDir, type: 'bun-workspaces'}\n      }\n      return {lockfiles: [], root: currentDir, type: 'npm-workspaces'}\n    }\n\n    currentDir = path.dirname(currentDir)\n  }\n\n  // No workspace or lockfile found, use the starting directory as root\n  return {lockfiles: [], root: startDir, type: 'standalone'}\n}\n\n/**\n * Determines the workspace type from the lockfiles found at the workspace root.\n * Uses the same priority order as LOCKFILE_NAMES (pnpm, npm, yarn, bun)\n * so that workspace.type and workspace.lockfile.type always agree.\n */\nfunction getWorkspaceType(lockfiles: LockfileInfo[]): WorkspaceType {\n  if (lockfiles.some((l) => l.type === 'pnpm')) return 'pnpm-workspaces'\n  if (lockfiles.some((l) => l.type === 'npm')) return 'npm-workspaces'\n  if (lockfiles.some((l) => l.type === 'yarn')) return 'yarn-workspaces'\n  if (lockfiles.some((l) => l.type === 'bun')) return 'bun-workspaces'\n  return 'npm-workspaces'\n}\n\nasync function findLockfiles(dir: string): Promise<LockfileInfo[]> {\n  const results = await Promise.all(\n    LOCKFILE_NAMES.map(async (name) => {\n      const lockfilePath = path.join(dir, name)\n      return (await fileExists(lockfilePath))\n        ? {path: lockfilePath, type: LOCKFILE_MAP[name]}\n        : null\n    }),\n  )\n  return results.filter((r): r is LockfileInfo => r !== null)\n}\n\nasync function fileExists(filePath: string): Promise<boolean> {\n  try {\n    await fs.access(filePath)\n    return true\n  } catch {\n    return false\n  }\n}\n"],"names":["fs","path","readJsonFile","LOCKFILE_MAP","LOCKFILE_NAMES","detectWorkspace","cwd","nearestPackageJson","findNearestPackageJson","bunfig","hasMultipleLockfiles","lockfile","root","type","yarnBerry","lockfiles","findWorkspaceRoot","dirname","uniquePmTypes","Set","map","l","size","length","Promise","all","fileExists","join","startDir","currentDir","resolve","parse","packageJsonPath","fsRoot","findLockfiles","pnpmWorkspacePath","packageJson","workspaces","getWorkspaceType","some","dir","results","name","lockfilePath","filter","r","filePath","access"],"mappings":"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"}

package/dist/util/packageManager/installationInfo/index.js

@@ -0,0 +1,4 @@
+// Main entry point
+export { detectCliInstallation } from './detectCliInstallation.js';
+
+//# sourceMappingURL=index.js.map

package/dist/util/packageManager/installationInfo/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/util/packageManager/installationInfo/index.ts"],"sourcesContent":["// Main entry point\nexport {detectCliInstallation} from './detectCliInstallation.js'\n"],"names":["detectCliInstallation"],"mappings":"AAAA,mBAAmB;AACnB,SAAQA,qBAAqB,QAAO,6BAA4B"}

package/dist/util/packageManager/installationInfo/readJsonFile.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs/promises';
+/**
+ * Reads and parses a JSON file, returning null if the file doesn't exist
+ * or contains invalid JSON.
+ */ export async function readJsonFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    } catch  {
+        return null;
+    }
+}
+
+//# sourceMappingURL=readJsonFile.js.map

package/dist/util/packageManager/installationInfo/readJsonFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/util/packageManager/installationInfo/readJsonFile.ts"],"sourcesContent":["import fs from 'node:fs/promises'\n\n/**\n * Reads and parses a JSON file, returning null if the file doesn't exist\n * or contains invalid JSON.\n */\nexport async function readJsonFile<T = Record<string, unknown>>(\n  filePath: string,\n): Promise<T | null> {\n  try {\n    const content = await fs.readFile(filePath, 'utf8')\n    return JSON.parse(content) as T\n  } catch {\n    return null\n  }\n}\n"],"names":["fs","readJsonFile","filePath","content","readFile","JSON","parse"],"mappings":"AAAA,OAAOA,QAAQ,mBAAkB;AAEjC;;;CAGC,GACD,OAAO,eAAeC,aACpBC,QAAgB;IAEhB,IAAI;QACF,MAAMC,UAAU,MAAMH,GAAGI,QAAQ,CAACF,UAAU;QAC5C,OAAOG,KAAKC,KAAK,CAACH;IACpB,EAAE,OAAM;QACN,OAAO;IACT;AACF"}

package/dist/util/packageManager/installationInfo/resolveVersionRange.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import yaml from 'yaml';
+/**
+ * Resolves a version range that may use special protocols like `catalog:` or `catalog:name`.
+ *
+ * @param declaredRange - The version range as declared in package.json
+ * @param packageName - The name of the package (needed for catalog lookup)
+ * @param workspaceInfo - Workspace configuration for finding catalog definitions
+ * @returns The resolved version range, or the original if it can't be resolved
+ */ export async function resolveVersionRange(declaredRange, packageName, workspaceInfo) {
+    // Handle catalog: protocol (pnpm workspaces)
+    if (declaredRange.startsWith('catalog:')) {
+        return resolveCatalogRange(declaredRange, packageName, workspaceInfo);
+    }
+    // Other protocols (workspace:*, etc.) are returned as-is
+    // They're handled differently in the dependency resolution
+    return declaredRange;
+}
+async function resolveCatalogRange(declaredRange, packageName, workspaceInfo) {
+    // Parse catalog name from "catalog:" or "catalog:name"
+    const catalogName = declaredRange.slice('catalog:'.length) || 'default';
+    // Read pnpm-workspace.yaml from workspace root
+    const pnpmWorkspacePath = path.join(workspaceInfo.root, 'pnpm-workspace.yaml');
+    try {
+        const content = await fs.readFile(pnpmWorkspacePath, 'utf8');
+        const config = yaml.parse(content);
+        // pnpm supports the default catalog in two places:
+        // 1. Top-level `catalog:` key
+        // 2. Under `catalogs: { default: { ... } }`
+        const version = catalogName === 'default' ? config.catalog?.[packageName] ?? config.catalogs?.['default']?.[packageName] : config.catalogs?.[catalogName]?.[packageName];
+        if (version) {
+            return version;
+        }
+    } catch  {
+    // Failed to read or parse pnpm-workspace.yaml
+    }
+    // Couldn't resolve - return original
+    return declaredRange;
+}
+
+//# sourceMappingURL=resolveVersionRange.js.map

package/dist/util/packageManager/installationInfo/resolveVersionRange.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/util/packageManager/installationInfo/resolveVersionRange.ts"],"sourcesContent":["import fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport yaml from 'yaml'\n\nimport {type WorkspaceInfo} from './types.js'\n\ninterface PnpmWorkspaceConfig {\n  catalog?: Record<string, string>\n  catalogs?: Record<string, Record<string, string>>\n  packages?: string[]\n}\n\n/**\n * Resolves a version range that may use special protocols like `catalog:` or `catalog:name`.\n *\n * @param declaredRange - The version range as declared in package.json\n * @param packageName - The name of the package (needed for catalog lookup)\n * @param workspaceInfo - Workspace configuration for finding catalog definitions\n * @returns The resolved version range, or the original if it can't be resolved\n */\nexport async function resolveVersionRange(\n  declaredRange: string,\n  packageName: string,\n  workspaceInfo: WorkspaceInfo,\n): Promise<string> {\n  // Handle catalog: protocol (pnpm workspaces)\n  if (declaredRange.startsWith('catalog:')) {\n    return resolveCatalogRange(declaredRange, packageName, workspaceInfo)\n  }\n\n  // Other protocols (workspace:*, etc.) are returned as-is\n  // They're handled differently in the dependency resolution\n  return declaredRange\n}\n\nasync function resolveCatalogRange(\n  declaredRange: string,\n  packageName: string,\n  workspaceInfo: WorkspaceInfo,\n): Promise<string> {\n  // Parse catalog name from \"catalog:\" or \"catalog:name\"\n  const catalogName = declaredRange.slice('catalog:'.length) || 'default'\n\n  // Read pnpm-workspace.yaml from workspace root\n  const pnpmWorkspacePath = path.join(workspaceInfo.root, 'pnpm-workspace.yaml')\n\n  try {\n    const content = await fs.readFile(pnpmWorkspacePath, 'utf8')\n    const config = yaml.parse(content) as PnpmWorkspaceConfig\n\n    // pnpm supports the default catalog in two places:\n    // 1. Top-level `catalog:` key\n    // 2. Under `catalogs: { default: { ... } }`\n    const version =\n      catalogName === 'default'\n        ? (config.catalog?.[packageName] ?? config.catalogs?.['default']?.[packageName])\n        : config.catalogs?.[catalogName]?.[packageName]\n\n    if (version) {\n      return version\n    }\n  } catch {\n    // Failed to read or parse pnpm-workspace.yaml\n  }\n\n  // Couldn't resolve - return original\n  return declaredRange\n}\n"],"names":["fs","path","yaml","resolveVersionRange","declaredRange","packageName","workspaceInfo","startsWith","resolveCatalogRange","catalogName","slice","length","pnpmWorkspacePath","join","root","content","readFile","config","parse","version","catalog","catalogs"],"mappings":"AAAA,OAAOA,QAAQ,mBAAkB;AACjC,OAAOC,UAAU,YAAW;AAE5B,OAAOC,UAAU,OAAM;AAUvB;;;;;;;CAOC,GACD,OAAO,eAAeC,oBACpBC,aAAqB,EACrBC,WAAmB,EACnBC,aAA4B;IAE5B,6CAA6C;IAC7C,IAAIF,cAAcG,UAAU,CAAC,aAAa;QACxC,OAAOC,oBAAoBJ,eAAeC,aAAaC;IACzD;IAEA,yDAAyD;IACzD,2DAA2D;IAC3D,OAAOF;AACT;AAEA,eAAeI,oBACbJ,aAAqB,EACrBC,WAAmB,EACnBC,aAA4B;IAE5B,uDAAuD;IACvD,MAAMG,cAAcL,cAAcM,KAAK,CAAC,WAAWC,MAAM,KAAK;IAE9D,+CAA+C;IAC/C,MAAMC,oBAAoBX,KAAKY,IAAI,CAACP,cAAcQ,IAAI,EAAE;IAExD,IAAI;QACF,MAAMC,UAAU,MAAMf,GAAGgB,QAAQ,CAACJ,mBAAmB;QACrD,MAAMK,SAASf,KAAKgB,KAAK,CAACH;QAE1B,mDAAmD;QACnD,8BAA8B;QAC9B,4CAA4C;QAC5C,MAAMI,UACJV,gBAAgB,YACXQ,OAAOG,OAAO,EAAE,CAACf,YAAY,IAAIY,OAAOI,QAAQ,EAAE,CAAC,UAAU,EAAE,CAAChB,YAAY,GAC7EY,OAAOI,QAAQ,EAAE,CAACZ,YAAY,EAAE,CAACJ,YAAY;QAEnD,IAAIc,SAAS;YACX,OAAOA;QACT;IACF,EAAE,OAAM;IACN,8CAA8C;IAChD;IAEA,qCAAqC;IACrC,OAAOf;AACT"}

package/dist/util/packageManager/installationInfo/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

package/dist/util/packageManager/installationInfo/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/util/packageManager/installationInfo/types.ts"],"sourcesContent":["import {type PackageManager} from '../packageManagerChoice.js'\n\n/** Lockfile types — excludes 'manual' since lockfiles always map to a real package manager. */\nexport type LockfileType = Exclude<PackageManager, 'manual'>\n\nexport type WorkspaceType =\n  | 'bun-workspaces'\n  | 'npm-workspaces'\n  | 'pnpm-workspaces'\n  | 'standalone'\n  | 'yarn-workspaces'\n\nexport type SanityPackage = '@sanity/cli' | 'sanity'\n\nexport interface CliInstallationInfo {\n  currentExecution: ExecutionContext\n  globalInstallations: GlobalInstallation[]\n  issues: Issue[]\n  packages: Partial<Record<SanityPackage, PackageInfo>>\n  workspace: WorkspaceInfo\n}\n\nexport interface ExecutionContext {\n  binaryPath: string | null\n  packageManager: PackageManager | null\n  resolvedFrom: 'global' | 'local' | 'npx' | 'unknown'\n}\n\nexport interface WorkspaceInfo {\n  /** True when bunfig.toml exists at workspace root (bun project marker). */\n  bunfig: boolean\n  hasMultipleLockfiles: boolean\n  lockfile: {\n    path: string\n    type: LockfileType\n  } | null\n  nearestPackageJson: string | null\n  root: string\n  type: WorkspaceType\n  /** True when .yarnrc.yml exists at workspace root (Yarn Berry / v2+). */\n  yarnBerry: boolean\n}\n\nexport interface PackageInfo {\n  declared: PackageDeclaration | null\n  installed: InstalledPackage | null\n  override: PackageOverride | null\n}\n\nexport interface PackageDeclaration {\n  declaredVersionRange: string\n  dependencyType: 'dependencies' | 'devDependencies'\n  packageJsonPath: string\n  versionRange: string\n}\n\nexport interface PackageOverride {\n  mechanism: 'npm-overrides' | 'pnpm-overrides' | 'yarn-resolutions'\n  packageJsonPath: string\n  versionRange: string\n}\n\nexport interface InstalledPackage {\n  cliDependencyRange: string | null\n  path: string\n  version: string\n}\n\nexport interface GlobalInstallation {\n  isActive: boolean\n  packageManager: LockfileType\n  packageName: SanityPackage\n  /** Filesystem path to the global installation, or null when it can't be determined. */\n  path: string | null\n  version: string\n}\n\nexport type IssueType =\n  | 'cli-not-installed'\n  | 'cli-version-incompatible'\n  | 'conflicting-cli-dependency'\n  | 'declared-not-installed'\n  | 'global-cli-incompatible'\n  | 'global-local-mismatch'\n  | 'multiple-lockfiles'\n  | 'override-in-effect'\n  | 'redundant-cli-dependency'\n\nexport type IssueSeverity = 'error' | 'info' | 'warning'\n\nexport interface Issue {\n  message: string\n  packageName: SanityPackage | null\n  severity: IssueSeverity\n  suggestion: string | null\n  type: IssueType\n}\n\nexport {type PackageManager} from '../packageManagerChoice.js'\n"],"names":[],"mappings":"AAkGA,WAA8D"}

package/dist/util/packageManager/packageManagerChoice.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { isInteractive } from '@sanity/cli-core';
+import { getRunningPackageManager } from '@sanity/cli-core/package-manager';
 import { select } from '@sanity/cli-core/ux';
 // eslint-disable-next-line unicorn/no-named-default
 import { default as preferredPM } from 'preferred-pm';
@@ -157,25 +158,5 @@ async function getMostLikelyInstalledPackageManager(rootDir) {
     const running = getRunningPackageManager();
     return running && installed.includes(running) ? running : undefined;
 }
-function getRunningPackageManager() {
-    // Yes, the env var is lowercase - it is set by the package managers themselves
-    const agent = process.env.npm_config_user_agent || '';
-    if (agent.includes('yarn')) {
-        return 'yarn';
-    }
-    if (agent.includes('pnpm')) {
-        return 'pnpm';
-    }
-    if (agent.includes('bun')) {
-        return 'bun';
-    }
-    // Both yarn and pnpm does a `npm/?` thing, thus the slightly different match here
-    // Theoretically not needed since we check for yarn/pnpm above, but in case other
-    // package managers do the same thing, we'll (hopefully) catch them here.
-    if (/^npm\/\d/.test(agent)) {
-        return 'npm';
-    }
-    return undefined;
-}
 
 //# sourceMappingURL=packageManagerChoice.js.map

package/dist/util/packageManager/packageManagerChoice.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/util/packageManager/packageManagerChoice.ts"],"sourcesContent":["import path from 'node:path'\n\nimport {isInteractive} from '@sanity/cli-core'\nimport {select} from '@sanity/cli-core/ux'\n// eslint-disable-next-line unicorn/no-named-default\nimport {default as preferredPM} from 'preferred-pm'\nimport which from 'which'\n\nexport type PackageManager = 'bun' | 'manual' | 'npm' | 'pnpm' | 'yarn'\n\nconst EXPERIMENTAL = new Set(['bun'])\n\nexport const ALLOWED_PACKAGE_MANAGERS: readonly PackageManager[] = [\n  'npm',\n  'yarn',\n  'pnpm',\n  'bun',\n  'manual',\n] as const\n\nexport const allowedPackageManagersString = ALLOWED_PACKAGE_MANAGERS.join(' | ')\n\n/**\n * Attempts to resolve the most optimal package manager to use to install/upgrade\n * packages/dependencies at a given path. It does so by looking for package manager\n * specific lockfiles. If it finds a lockfile belonging to a certain package manager,\n * it prioritizes this one. However, if that package manager is not installed, it will\n * prompt the user for which one they want to use and hint at the most optimal one\n * not being installed.\n *\n * Note that this function also takes local npm binary paths into account - for instance,\n * `yarn` can be installed as a dependency of the project instead of globally, and it\n * will use that is available.\n *\n * The user can also select 'manual' to skip the process and run their preferred package\n * manager manually. Commands using this function must take this `manual` choice into\n * account and act accordingly if chosen.\n *\n * @param workDir - The working directory where a lockfile is most likely to be present\n * @param options - Pass `interactive: false` to fall back to npm if most optimal is\n *                  not available, instead of prompting\n * @returns Object of `chosen` and, if a lockfile is found, the `mostOptimal` choice\n */\nexport async function getPackageManagerChoice(\n  workDir: string,\n  options: {interactive: boolean},\n): Promise<{chosen: PackageManager; mostOptimal?: PackageManager}> {\n  const rootDir = workDir || process.cwd()\n  const preferred = (await preferredPM(rootDir))?.name\n\n  if (preferred && (await hasCommand(preferred, rootDir))) {\n    // There is an optimal/preferred package manager, and the user has it installed!\n    return {chosen: preferred, mostOptimal: preferred}\n  }\n\n  const mostLikelyPM = await getMostLikelyInstalledPackageManager(rootDir)\n  const interactive =\n    typeof options.interactive === 'boolean' ? options.interactive : isInteractive()\n  if (!interactive) {\n    // We can't ask the user for their preference, so fall back to either the one that is being run\n    // or whatever is installed on the system (npm being the preferred choice).\n    // Note that the most optimal choice is already picked above if available.\n    return {chosen: mostLikelyPM || (await getFallback(rootDir)), mostOptimal: preferred}\n  }\n\n  // We can ask the user for their preference, hurray!\n  const messageSuffix = preferred ? ` (preferred is ${preferred}, but is not installed)` : ''\n  const installed = await getAvailablePackageManagers(rootDir)\n  const chosen = await select<PackageManager>({\n    choices: installed.map((pm) => ({\n      name: EXPERIMENTAL.has(pm) ? `${pm} (experimental)` : pm,\n      value: pm,\n    })),\n    default: preferred || mostLikelyPM,\n    message: `Package manager to use for installing dependencies?${messageSuffix}`,\n  })\n\n  return {chosen, mostOptimal: preferred}\n}\n\nasync function getFallback(cwd: string): Promise<PackageManager> {\n  if (await hasNpmInstalled(cwd)) {\n    return 'npm'\n  }\n\n  if (await hasYarnInstalled(cwd)) {\n    return 'yarn'\n  }\n\n  if (await hasPnpmInstalled(cwd)) {\n    return 'pnpm'\n  }\n\n  if (await hasBunInstalled(cwd)) {\n    return 'bun'\n  }\n\n  return 'manual'\n}\n\nasync function getAvailablePackageManagers(cwd: string): Promise<PackageManager[]> {\n  const [npm, yarn, pnpm, bun] = await Promise.all([\n    hasNpmInstalled(cwd),\n    hasYarnInstalled(cwd),\n    hasPnpmInstalled(cwd),\n    hasBunInstalled(cwd),\n  ])\n\n  const choices = [npm && 'npm', yarn && 'yarn', pnpm && 'pnpm', bun && 'bun', 'manual']\n  return choices.filter((pm): pm is PackageManager => pm !== false)\n}\n\nfunction hasNpmInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('npm', cwd)\n}\n\nfunction hasYarnInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('yarn', cwd)\n}\n\nfunction hasPnpmInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('pnpm', cwd)\n}\n\nfunction hasBunInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('bun', cwd)\n}\n\nfunction getNpmRunPath(cwd: string): string {\n  let previous\n  let cwdPath = path.resolve(cwd)\n  const result: string[] = []\n\n  while (previous !== cwdPath) {\n    result.push(path.join(cwdPath, 'node_modules', '.bin'))\n    previous = cwdPath\n    cwdPath = path.resolve(cwdPath, '..')\n  }\n\n  result.push(path.resolve(cwd, process.execPath, '..'))\n\n  const pathEnv = process.env[getPathEnvVarKey()]\n  return [...result, pathEnv].join(path.delimiter)\n}\n\nexport function getPartialEnvWithNpmPath(cwd: string): NodeJS.ProcessEnv {\n  const key = getPathEnvVarKey()\n  return {[key]: getNpmRunPath(cwd)}\n}\n\nfunction getPathEnvVarKey(): string {\n  if (process.platform !== 'win32') {\n    return 'PATH'\n  }\n\n  return (\n    Object.keys(process.env)\n      .toReversed()\n      .find((key) => key.toUpperCase() === 'PATH') || 'Path'\n  )\n}\n\nfunction getCommandPath(cmd: string, cwd?: string): Promise<string | null> {\n  const options = cwd ? {path: getNpmRunPath(cwd)} : undefined\n  return which(cmd, options).catch(() => null)\n}\n\nfunction hasCommand(cmd: string, cwd?: string): Promise<boolean> {\n  return getCommandPath(cmd, cwd).then((cmdPath) => cmdPath !== null)\n}\n\nasync function getMostLikelyInstalledPackageManager(\n  rootDir: string,\n): Promise<PackageManager | undefined> {\n  const installed = await getAvailablePackageManagers(rootDir)\n  const running = getRunningPackageManager()\n  return running && installed.includes(running) ? running : undefined\n}\n\nfunction getRunningPackageManager(): PackageManager | undefined {\n  // Yes, the env var is lowercase - it is set by the package managers themselves\n  const agent = process.env.npm_config_user_agent || ''\n\n  if (agent.includes('yarn')) {\n    return 'yarn'\n  }\n\n  if (agent.includes('pnpm')) {\n    return 'pnpm'\n  }\n\n  if (agent.includes('bun')) {\n    return 'bun'\n  }\n\n  // Both yarn and pnpm does a `npm/?` thing, thus the slightly different match here\n  // Theoretically not needed since we check for yarn/pnpm above, but in case other\n  // package managers do the same thing, we'll (hopefully) catch them here.\n  if (/^npm\\/\\d/.test(agent)) {\n    return 'npm'\n  }\n\n  return undefined\n}\n"],"names":["path","isInteractive","select","default","preferredPM","which","EXPERIMENTAL","Set","ALLOWED_PACKAGE_MANAGERS","allowedPackageManagersString","join","getPackageManagerChoice","workDir","options","rootDir","process","cwd","preferred","name","hasCommand","chosen","mostOptimal","mostLikelyPM","getMostLikelyInstalledPackageManager","interactive","getFallback","messageSuffix","installed","getAvailablePackageManagers","choices","map","pm","has","value","message","hasNpmInstalled","hasYarnInstalled","hasPnpmInstalled","hasBunInstalled","npm","yarn","pnpm","bun","Promise","all","filter","getNpmRunPath","previous","cwdPath","resolve","result","push","execPath","pathEnv","env","getPathEnvVarKey","delimiter","getPartialEnvWithNpmPath","key","platform","Object","keys","toReversed","find","toUpperCase","getCommandPath","cmd","undefined","catch","then","cmdPath","running","getRunningPackageManager","includes","agent","npm_config_user_agent","test"],"mappings":"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"}
+{"version":3,"sources":["../../../src/util/packageManager/packageManagerChoice.ts"],"sourcesContent":["import path from 'node:path'\n\nimport {isInteractive} from '@sanity/cli-core'\nimport {getRunningPackageManager} from '@sanity/cli-core/package-manager'\nimport {select} from '@sanity/cli-core/ux'\n// eslint-disable-next-line unicorn/no-named-default\nimport {default as preferredPM} from 'preferred-pm'\nimport which from 'which'\n\nexport type PackageManager = 'bun' | 'manual' | 'npm' | 'pnpm' | 'yarn'\n\nconst EXPERIMENTAL = new Set(['bun'])\n\nexport const ALLOWED_PACKAGE_MANAGERS: readonly PackageManager[] = [\n  'npm',\n  'yarn',\n  'pnpm',\n  'bun',\n  'manual',\n] as const\n\nexport const allowedPackageManagersString = ALLOWED_PACKAGE_MANAGERS.join(' | ')\n\n/**\n * Attempts to resolve the most optimal package manager to use to install/upgrade\n * packages/dependencies at a given path. It does so by looking for package manager\n * specific lockfiles. If it finds a lockfile belonging to a certain package manager,\n * it prioritizes this one. However, if that package manager is not installed, it will\n * prompt the user for which one they want to use and hint at the most optimal one\n * not being installed.\n *\n * Note that this function also takes local npm binary paths into account - for instance,\n * `yarn` can be installed as a dependency of the project instead of globally, and it\n * will use that is available.\n *\n * The user can also select 'manual' to skip the process and run their preferred package\n * manager manually. Commands using this function must take this `manual` choice into\n * account and act accordingly if chosen.\n *\n * @param workDir - The working directory where a lockfile is most likely to be present\n * @param options - Pass `interactive: false` to fall back to npm if most optimal is\n *                  not available, instead of prompting\n * @returns Object of `chosen` and, if a lockfile is found, the `mostOptimal` choice\n */\nexport async function getPackageManagerChoice(\n  workDir: string,\n  options: {interactive: boolean},\n): Promise<{chosen: PackageManager; mostOptimal?: PackageManager}> {\n  const rootDir = workDir || process.cwd()\n  const preferred = (await preferredPM(rootDir))?.name\n\n  if (preferred && (await hasCommand(preferred, rootDir))) {\n    // There is an optimal/preferred package manager, and the user has it installed!\n    return {chosen: preferred, mostOptimal: preferred}\n  }\n\n  const mostLikelyPM = await getMostLikelyInstalledPackageManager(rootDir)\n  const interactive =\n    typeof options.interactive === 'boolean' ? options.interactive : isInteractive()\n  if (!interactive) {\n    // We can't ask the user for their preference, so fall back to either the one that is being run\n    // or whatever is installed on the system (npm being the preferred choice).\n    // Note that the most optimal choice is already picked above if available.\n    return {chosen: mostLikelyPM || (await getFallback(rootDir)), mostOptimal: preferred}\n  }\n\n  // We can ask the user for their preference, hurray!\n  const messageSuffix = preferred ? ` (preferred is ${preferred}, but is not installed)` : ''\n  const installed = await getAvailablePackageManagers(rootDir)\n  const chosen = await select<PackageManager>({\n    choices: installed.map((pm) => ({\n      name: EXPERIMENTAL.has(pm) ? `${pm} (experimental)` : pm,\n      value: pm,\n    })),\n    default: preferred || mostLikelyPM,\n    message: `Package manager to use for installing dependencies?${messageSuffix}`,\n  })\n\n  return {chosen, mostOptimal: preferred}\n}\n\nasync function getFallback(cwd: string): Promise<PackageManager> {\n  if (await hasNpmInstalled(cwd)) {\n    return 'npm'\n  }\n\n  if (await hasYarnInstalled(cwd)) {\n    return 'yarn'\n  }\n\n  if (await hasPnpmInstalled(cwd)) {\n    return 'pnpm'\n  }\n\n  if (await hasBunInstalled(cwd)) {\n    return 'bun'\n  }\n\n  return 'manual'\n}\n\nasync function getAvailablePackageManagers(cwd: string): Promise<PackageManager[]> {\n  const [npm, yarn, pnpm, bun] = await Promise.all([\n    hasNpmInstalled(cwd),\n    hasYarnInstalled(cwd),\n    hasPnpmInstalled(cwd),\n    hasBunInstalled(cwd),\n  ])\n\n  const choices = [npm && 'npm', yarn && 'yarn', pnpm && 'pnpm', bun && 'bun', 'manual']\n  return choices.filter((pm): pm is PackageManager => pm !== false)\n}\n\nfunction hasNpmInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('npm', cwd)\n}\n\nfunction hasYarnInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('yarn', cwd)\n}\n\nfunction hasPnpmInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('pnpm', cwd)\n}\n\nfunction hasBunInstalled(cwd?: string): Promise<boolean> {\n  return hasCommand('bun', cwd)\n}\n\nfunction getNpmRunPath(cwd: string): string {\n  let previous\n  let cwdPath = path.resolve(cwd)\n  const result: string[] = []\n\n  while (previous !== cwdPath) {\n    result.push(path.join(cwdPath, 'node_modules', '.bin'))\n    previous = cwdPath\n    cwdPath = path.resolve(cwdPath, '..')\n  }\n\n  result.push(path.resolve(cwd, process.execPath, '..'))\n\n  const pathEnv = process.env[getPathEnvVarKey()]\n  return [...result, pathEnv].join(path.delimiter)\n}\n\nexport function getPartialEnvWithNpmPath(cwd: string): NodeJS.ProcessEnv {\n  const key = getPathEnvVarKey()\n  return {[key]: getNpmRunPath(cwd)}\n}\n\nfunction getPathEnvVarKey(): string {\n  if (process.platform !== 'win32') {\n    return 'PATH'\n  }\n\n  return (\n    Object.keys(process.env)\n      .toReversed()\n      .find((key) => key.toUpperCase() === 'PATH') || 'Path'\n  )\n}\n\nfunction getCommandPath(cmd: string, cwd?: string): Promise<string | null> {\n  const options = cwd ? {path: getNpmRunPath(cwd)} : undefined\n  return which(cmd, options).catch(() => null)\n}\n\nfunction hasCommand(cmd: string, cwd?: string): Promise<boolean> {\n  return getCommandPath(cmd, cwd).then((cmdPath) => cmdPath !== null)\n}\n\nasync function getMostLikelyInstalledPackageManager(\n  rootDir: string,\n): Promise<PackageManager | undefined> {\n  const installed = await getAvailablePackageManagers(rootDir)\n  const running = getRunningPackageManager()\n  return running && installed.includes(running) ? running : undefined\n}\n"],"names":["path","isInteractive","getRunningPackageManager","select","default","preferredPM","which","EXPERIMENTAL","Set","ALLOWED_PACKAGE_MANAGERS","allowedPackageManagersString","join","getPackageManagerChoice","workDir","options","rootDir","process","cwd","preferred","name","hasCommand","chosen","mostOptimal","mostLikelyPM","getMostLikelyInstalledPackageManager","interactive","getFallback","messageSuffix","installed","getAvailablePackageManagers","choices","map","pm","has","value","message","hasNpmInstalled","hasYarnInstalled","hasPnpmInstalled","hasBunInstalled","npm","yarn","pnpm","bun","Promise","all","filter","getNpmRunPath","previous","cwdPath","resolve","result","push","execPath","pathEnv","env","getPathEnvVarKey","delimiter","getPartialEnvWithNpmPath","key","platform","Object","keys","toReversed","find","toUpperCase","getCommandPath","cmd","undefined","catch","then","cmdPath","running","includes"],"mappings":"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"}