feat: improve detecting pm and support bun (electron-userland#9262)

The previous logic determined it was pnpm by checking if pnpm existed in
process.env. Actually, we should establish a priority: first check
npm_config_user_agent, after all checks are completed, then check exec
path, and finally check packageManager, which would be more accurate.

Author: beyondkmp

.changeset/rare-numbers-join.md

@@ -0,0 +1,5 @@
+---
+"app-builder-lib": patch
+---
+
+fix: enhance package manager detection to support Yarn Berry (#9261)

packages/app-builder-lib/src/node-module-collector/index.ts

@@ -1,7 +1,7 @@
 import { NpmNodeModulesCollector } from "./npmNodeModulesCollector"
 import { PnpmNodeModulesCollector } from "./pnpmNodeModulesCollector"
 import { YarnNodeModulesCollector } from "./yarnNodeModulesCollector"
-import { detectPackageManagerByLockfile, detectPackageManagerByEnv, PM, getPackageManagerCommand } from "./packageManager"
+import { detectPackageManagerByLockfile, detectPackageManagerByEnv, PM, getPackageManagerCommand, detectYarnBerry } from "./packageManager"
 import { NodeModuleInfo } from "./types"
 import { TmpDir } from "temp-file"
 
@@ -13,6 +13,7 @@ export async function getCollectorByPackageManager(pm: PM, rootDir: string, temp
       }
       return new PnpmNodeModulesCollector(rootDir, tempDirManager)
     case PM.NPM:
+    case PM.BUN:
       return new NpmNodeModulesCollector(rootDir, tempDirManager)
     case PM.YARN:
       return new YarnNodeModulesCollector(rootDir, tempDirManager)
@@ -29,14 +30,27 @@ export async function getNodeModules(pm: PM, rootDir: string, tempDirManager: Tm
 export function detectPackageManager(dirs: string[]): PM {
   let pm: PM | null = null
 
+  const resolveYarnVersion = (pm: PM) => {
+    if (pm === PM.YARN) {
+      return detectYarnBerry()
+    }
+    return pm
+  }
+
   for (const dir of dirs) {
     pm = detectPackageManagerByLockfile(dir)
     if (pm) {
-      return pm
+      return resolveYarnVersion(pm)
     }
   }
 
-  return detectPackageManagerByEnv("pnpm") || detectPackageManagerByEnv("yarn") || detectPackageManagerByEnv("npm") || PM.NPM
+  pm = detectPackageManagerByEnv()
+  if (pm) {
+    return resolveYarnVersion(pm)
+  }
+
+  // Default to npm
+  return PM.NPM
 }
 
 export { PM, getPackageManagerCommand }

packages/app-builder-lib/src/node-module-collector/packageManager.ts

@@ -1,12 +1,14 @@
 import * as path from "path"
 import * as fs from "fs"
 import * as which from "which"
+import { execSync } from "child_process"
 
 export enum PM {
   NPM = "npm",
   YARN = "yarn",
   PNPM = "pnpm",
   YARN_BERRY = "yarn-berry",
+  BUN = "bun",
 }
 
 // Cache for resolved paths
@@ -15,6 +17,7 @@ const pmPathCache: Record<PM, string | null | undefined> = {
   [PM.YARN]: undefined,
   [PM.PNPM]: undefined,
   [PM.YARN_BERRY]: undefined,
+  [PM.BUN]: undefined,
 }
 
 function resolveCommand(pm: PM): string {
@@ -42,46 +45,54 @@ export function getPackageManagerCommand(pm: PM) {
   return resolved
 }
 
-export function detectPackageManagerByEnv(pm: "npm" | "yarn" | "pnpm"): PM | null {
-  const ua = process.env.npm_config_user_agent ?? ""
-  const execPath = process.env.npm_execpath?.toLowerCase() ?? ""
+export function detectPackageManagerByEnv(): PM | null {
+  const packageJsonPath = path.join(process.cwd(), "package.json")
+  const packageManager = fs.existsSync(packageJsonPath) ? JSON.parse(fs.readFileSync(packageJsonPath, "utf8"))?.packageManager : undefined
 
-  const yarnVersion = process.env.YARN_VERSION
-  const isBerry = yarnVersion?.startsWith("2.") || yarnVersion?.startsWith("3.")
+  const priorityChecklist = [
+    (key: string) => process.env.npm_config_user_agent?.includes(key),
+    (key: string) => process.env.npm_execpath?.includes(key),
+    (key: string) => packageManager?.startsWith(`${key}@`),
+  ]
 
-  switch (pm) {
-    case "pnpm":
-      return ua.includes("pnpm") || execPath.includes("pnpm") || process.env.PNPM_HOME ? PM.PNPM : null
-    case "yarn":
-      if (ua.includes("yarn") || execPath.includes("yarn") || process.env.YARN_REGISTRY) {
-        return isBerry || ua.includes("yarn/2") || ua.includes("yarn/3") ? PM.YARN_BERRY : PM.YARN
+  const pms = Object.values(PM).filter(pm => pm !== PM.YARN_BERRY)
+  for (const checker of priorityChecklist) {
+    for (const pm of pms) {
+      if (checker(pm)) {
+        return pm
       }
-      return null
-    case "npm":
-      return ua.includes("npm") || execPath.includes("npm") || process.env.npm_package_json ? PM.NPM : null
-    default:
-      return null
+    }
   }
+  return null
 }
 
 export function detectPackageManagerByLockfile(cwd: string): PM | null {
   const has = (file: string) => fs.existsSync(path.join(cwd, file))
 
-  const yarn = has("yarn.lock")
-  const pnpm = has("pnpm-lock.yaml")
-  const npm = has("package-lock.json")
-
   const detected: PM[] = []
-  if (yarn) detected.push(PM.YARN)
-  if (pnpm) detected.push(PM.PNPM)
-  if (npm) detected.push(PM.NPM)
+  if (has("yarn.lock")) {
+    detected.push(PM.YARN)
+  }
+  if (has("pnpm-lock.yaml")) {
+    detected.push(PM.PNPM)
+  }
+  if (has("package-lock.json")) {
+    detected.push(PM.NPM)
+  }
+  if (has("bun.lock") || has("bun.lockb")) {
+    detected.push(PM.BUN)
+  }
 
   if (detected.length === 1) {
-    if (detected[0] === PM.YARN) {
-      return detectPackageManagerByEnv("yarn") === PM.YARN_BERRY ? PM.YARN_BERRY : PM.YARN
-    }
     return detected[0]
   }
 
   return null
 }
+
+export function detectYarnBerry() {
+  // yarn --version
+  const version = execSync("yarn --version").toString().trim()
+  if (parseInt(version.split(".")[0]) > 1) return PM.YARN_BERRY
+  return PM.YARN
+}