reset-framework-cli 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reset-framework-cli",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
   "description": "Command-line tooling for Reset Framework.",
   "license": "MIT",
@@ -11,9 +11,9 @@
     "node": ">=20.19.0"
   },
   "dependencies": {
-    "@reset-framework/native": "1.0.1",
-    "@reset-framework/schema": "1.0.1",
-    "@reset-framework/sdk": "1.0.1"
+    "@reset-framework/native": "1.0.2",
+    "@reset-framework/schema": "1.0.2",
+    "@reset-framework/sdk": "1.0.2"
   },
   "bin": {
     "reset-framework-cli": "src/index.js"

package/src/commands/build.js

@@ -1,12 +1,13 @@
 import { buildFrameworkRuntime } from "../lib/framework.js"
 import { stageMacOSAppBundle } from "../lib/output.js"
-import { resolveNpmCommand, runCommand } from "../lib/process.js"
+import { resolvePackageManagerCommand, runCommand } from "../lib/process.js"
 import {
   assertAppProject,
   assertFrameworkInstall,
   loadResetConfig,
   resolveAppOutputPaths,
   resolveAppPaths,
+  resolveAppPackageManager,
   resolveConfigPath,
   resolveFrontendDir,
   resolveFrameworkBuildPaths,
@@ -34,6 +35,7 @@ export async function run(context) {
   assertFrameworkInstall(frameworkPaths)
   const config = loadResetConfig(appPaths)
   assertAppProject(appPaths, config)
+  const packageManager = resolveAppPackageManager(appPaths, config)
   const outputPaths = resolveAppOutputPaths(appPaths, config)
   const configPath = resolveConfigPath(appPaths)
   const frontendDir = resolveFrontendDir(appPaths, config)
@@ -49,6 +51,7 @@ export async function run(context) {
   printKeyValueTable([
     ["Config", configPath],
     ["Frontend", frontendDir],
+    ["Package manager", packageManager],
     ["Output", outputPaths.appBundlePath]
   ])
   console.log("")
@@ -82,7 +85,7 @@ export async function run(context) {
   const progress = createProgress(steps.length, "Build")
 
   if (!skipFrontend) {
-    await runCommand(resolveNpmCommand(), ["run", "build"], {
+    await runCommand(resolvePackageManagerCommand(packageManager), ["run", "build"], {
       cwd: frontendDir,
       dryRun
     })

package/src/commands/dev.js

@@ -1,7 +1,7 @@
 import { buildFrameworkRuntime } from "../lib/framework.js"
 import {
   registerChildCleanup,
-  resolveNpmCommand,
+  resolvePackageManagerCommand,
   spawnCommand,
   waitForProcessExit,
   waitForUrl
@@ -11,6 +11,7 @@ import {
   assertFrameworkInstall,
   loadResetConfig,
   resolveAppPaths,
+  resolveAppPackageManager,
   resolveConfigPath,
   resolveDevServerOptions,
   resolveFrontendDir,
@@ -39,6 +40,7 @@ export async function run(context) {
   assertFrameworkInstall(frameworkPaths)
   const config = loadResetConfig(appPaths)
   assertAppProject(appPaths, config)
+  const packageManager = resolveAppPackageManager(appPaths, config)
   const devServer = resolveDevServerOptions(config)
   const configPath = resolveConfigPath(appPaths)
   const frontendDir = resolveFrontendDir(appPaths, config)
@@ -54,6 +56,7 @@ export async function run(context) {
   printKeyValueTable([
     ["Config", configPath],
     ["Frontend", frontendDir],
+    ["Package manager", packageManager],
     ["Dev URL", config.frontend.devUrl]
   ])
   console.log("")
@@ -97,7 +100,7 @@ export async function run(context) {
   const children = []
 
   if (!skipFrontend) {
-    const frontendProcess = spawnCommand(resolveNpmCommand(), [
+    const frontendProcess = spawnCommand(resolvePackageManagerCommand(packageManager), [
       "run",
       "dev",
       "--",

package/src/commands/init.js

@@ -3,12 +3,14 @@ import { cp, mkdir, readFile, readdir, writeFile } from "node:fs/promises"
 import path from "node:path"
 
 import {
+  captureCommandOutput,
   getInstallCommandArgs,
   resolvePackageManagerCommand,
   runCommand
 } from "../lib/process.js"
 import {
   makeAppMetadata,
+  resolveCliDependencySpec,
   resolveFrameworkPaths,
   resolveSdkDependencySpec
 } from "../lib/project.js"
@@ -172,6 +174,84 @@ function App() {
 export default App
 `
 
+const rootFrontendRunner = `import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+
+const script = process.argv[2]
+if (!script) {
+  throw new Error('Missing frontend script name.')
+}
+
+const appRoot = process.cwd()
+const config = JSON.parse(readFileSync(path.join(appRoot, 'reset.config.json'), 'utf8'))
+const frontendDir =
+  typeof config?.project?.frontendDir === 'string' && config.project.frontendDir.trim() !== ''
+    ? path.resolve(appRoot, config.project.frontendDir)
+    : path.join(appRoot, 'frontend')
+
+function resolvePackageManagerCommand() {
+  const packageJsonPath = path.join(appRoot, 'package.json')
+  const manifest = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+  const packageManager = typeof manifest.packageManager === 'string' ? manifest.packageManager.trim() : ''
+  const name = packageManager.split('@')[0]
+
+  if (name === 'bun') {
+    return process.platform === 'win32' ? 'bun.exe' : 'bun'
+  }
+
+  if (name === 'pnpm') {
+    return process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm'
+  }
+
+  if (name === 'yarn') {
+    return process.platform === 'win32' ? 'yarn.cmd' : 'yarn'
+  }
+
+  if (name === 'npm') {
+    return process.platform === 'win32' ? 'npm.cmd' : 'npm'
+  }
+
+  const candidates = [
+    ['bun.lock', process.platform === 'win32' ? 'bun.exe' : 'bun'],
+    ['bun.lockb', process.platform === 'win32' ? 'bun.exe' : 'bun'],
+    ['pnpm-lock.yaml', process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm'],
+    ['yarn.lock', process.platform === 'win32' ? 'yarn.cmd' : 'yarn'],
+    ['package-lock.json', process.platform === 'win32' ? 'npm.cmd' : 'npm']
+  ]
+
+  for (const [fileName, command] of candidates) {
+    try {
+      readFileSync(path.join(appRoot, fileName), 'utf8')
+      return command
+    } catch {}
+  }
+
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm'
+}
+
+const command = resolvePackageManagerCommand()
+const child = spawn(command, ['run', script, '--', ...process.argv.slice(3)], {
+  cwd: frontendDir,
+  stdio: 'inherit',
+  env: process.env
+})
+
+child.once('error', (error) => {
+  console.error(error)
+  process.exit(1)
+})
+
+child.once('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal)
+    return
+  }
+
+  process.exit(code ?? 1)
+})
+`
+
 export const description = "Scaffold a starter app with an interactive project setup"
 
 function listTemplates(templatesDir) {
@@ -183,15 +263,84 @@ function listTemplates(templatesDir) {
 
 function getRootGitignore(frontendDir) {
   if (frontendDir === ".") {
-    return `.reset
-node_modules
-dist
+    return `.DS_Store
+Thumbs.db
+.idea/
+.vs/
+.vscode/
+.cache/
+.reset/
+.turbo/
+build/
+coverage/
+dist/
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+*.log
+*.zip
+*.tgz
+*.tsbuildinfo
+*.dSYM/
+.env
+.env.*
+.env.local
+.env.*.local
+.eslintcache
+bun.lock
+bun.lockb
+compile_commands.json
+CMakeUserPresets.json
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+install_manifest.txt
+cmake-build-*/
+Testing/
+scripts/local/
 `
   }
 
-  return `.reset
-${frontendDir}/node_modules
-${frontendDir}/dist
+  return `.DS_Store
+Thumbs.db
+.idea/
+.vs/
+.vscode/
+.cache/
+.reset/
+.turbo/
+build/
+coverage/
+node_modules/
+${frontendDir}/node_modules/
+${frontendDir}/dist/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+*.log
+*.zip
+*.tgz
+*.tsbuildinfo
+*.dSYM/
+.env
+.env.*
+.env.local
+.env.*.local
+.eslintcache
+bun.lock
+bun.lockb
+compile_commands.json
+CMakeUserPresets.json
+CMakeCache.txt
+CMakeFiles/
+cmake_install.cmake
+install_manifest.txt
+cmake-build-*/
+Testing/
+scripts/local/
 `
 }
 
@@ -310,6 +459,91 @@ async function applyFrontendOverrides(frontendDir, options) {
   await writeFile(path.join(frontendDir, "vite.config.ts"), standaloneViteConfig, "utf8")
 }
 
+function createRootPackageJson(options) {
+  const packageManagerVersion = options.packageManagerVersion
+    ? `${options.packageManager}@${options.packageManagerVersion}`
+    : undefined
+
+  const base = {
+    name: options.appName,
+    private: true,
+    version: "0.1.0",
+    description: `${options.productName} desktop app`,
+    scripts: {
+      dev: "reset-framework-cli dev",
+      build: "reset-framework-cli build",
+      package: "reset-framework-cli package",
+      doctor: "reset-framework-cli doctor"
+    },
+    devDependencies: {
+      "reset-framework-cli": options.cliDependencySpec
+    }
+  }
+
+  if (packageManagerVersion) {
+    base.packageManager = packageManagerVersion
+  }
+
+  if (options.frontendDir !== ".") {
+    base.workspaces = [options.frontendDir]
+    base.scripts["dev:web"] = "node ./scripts/run-frontend.mjs dev"
+    base.scripts["build:web"] = "node ./scripts/run-frontend.mjs build"
+    base.scripts["lint:web"] = "node ./scripts/run-frontend.mjs lint"
+    base.scripts["preview:web"] = "node ./scripts/run-frontend.mjs preview"
+  }
+
+  return base
+}
+
+function createRootReadme(options) {
+  const run = `${options.packageManager} run`
+  const webPath = options.frontendDir === "." ? "project root" : `${options.frontendDir}/`
+
+  return `# ${options.productName}
+
+Generated with \`reset-framework-cli\`.
+
+## Commands
+
+- \`${run} dev\`: start the frontend dev server and native desktop runtime
+- \`${run} build\`: build the frontend and stage the desktop app bundle
+- \`${run} package\`: archive the built desktop app
+- \`${run} doctor\`: inspect the project and framework installation
+
+## Web-only commands
+
+${options.frontendDir === "." ? `- \`${run} dev:web\`: run the Vite frontend only
+- \`${run} build:web\`: build the frontend only` : `- \`${run} dev:web\`: run the frontend workspace only
+- \`${run} build:web\`: build the frontend workspace only`}
+
+## Project files
+
+- \`reset.config.json\`: desktop app metadata and runtime configuration
+- \`${webPath}\`: web frontend source
+- \`.reset/\`: generated build output and native runtime cache
+`
+}
+
+async function writeRootPackageFiles(options) {
+  await writeFile(
+    path.join(options.targetDir, "README.md"),
+    createRootReadme(options),
+    "utf8"
+  )
+
+  if (options.frontendDir !== ".") {
+    await writeFile(
+      path.join(options.targetDir, "package.json"),
+      JSON.stringify(createRootPackageJson(options), null, 2) + "\n",
+      "utf8"
+    )
+
+    const scriptsDir = path.join(options.targetDir, "scripts")
+    await mkdir(scriptsDir, { recursive: true })
+    await writeFile(path.join(scriptsDir, "run-frontend.mjs"), rootFrontendRunner, "utf8")
+  }
+}
+
 async function writeProjectFiles(options) {
   const templateConfig = JSON.parse(await readFile(options.templateConfigPath, "utf8"))
 
@@ -343,6 +577,20 @@ async function writeProjectFiles(options) {
   )
 }
 
+async function resolvePackageManagerVersion(packageManager) {
+  if (packageManager !== "npm" && packageManager !== "pnpm" && packageManager !== "yarn" && packageManager !== "bun") {
+    return null
+  }
+
+  try {
+    const command = resolvePackageManagerCommand(packageManager)
+    const result = await captureCommandOutput(command, ["--version"])
+    return typeof result === "string" && result.trim() !== "" ? result.trim() : null
+  } catch {
+    return null
+  }
+}
+
 async function collectCreateAppOptions(context, templates) {
   const initialTarget = context.args[0] ?? "my-app"
   const defaultTargetDir = path.resolve(context.cwd, initialTarget)
@@ -377,8 +625,10 @@ async function collectCreateAppOptions(context, templates) {
       templateDir: path.join(frameworkPaths.templatesDir, defaults.templateName),
       templateConfigPath: path.join(frameworkPaths.templatesDir, defaults.templateName, "reset.config.json"),
       sourceFrontendDir: path.join(frameworkPaths.templatesDir, defaults.templateName, "frontend"),
+      cliDependencySpec: resolveCliDependencySpec(frameworkPaths),
       sdkDependencySpec: resolveSdkDependencySpec(frameworkPaths),
       packageManager: resolvePackageManagerOption(context),
+      packageManagerVersion: await resolvePackageManagerVersion(resolvePackageManagerOption(context)),
       installDependencies: !context.flags["no-install"],
       force: Boolean(context.flags.force)
     }
@@ -464,6 +714,33 @@ async function collectCreateAppOptions(context, templates) {
       defaultValue: true
     })
 
+    const packageManager = await promptSelect(rl, {
+      label: "Package manager",
+      defaultValue: resolvePackageManagerOption(context),
+      choices: [
+        {
+          value: "npm",
+          label: "npm",
+          description: "Wide compatibility and predictable installs."
+        },
+        {
+          value: "bun",
+          label: "bun",
+          description: "Fast installs and lets bun run the root desktop scripts."
+        },
+        {
+          value: "pnpm",
+          label: "pnpm",
+          description: "Strict dependency graph with workspace support."
+        },
+        {
+          value: "yarn",
+          label: "yarn",
+          description: "Classic workspace-based JavaScript package workflow."
+        }
+      ]
+    })
+
     printSection("Summary")
     printKeyValueTable([
       ["Directory", targetDir],
@@ -472,6 +749,7 @@ async function collectCreateAppOptions(context, templates) {
       ["App ID", appId],
       ["Frontend", frontendDir === "." ? "project root" : `${frontendDir}/`],
       ["Styling", styling],
+      ["Package manager", packageManager],
       ["Install", installDependencies ? "yes" : "no"]
     ])
     console.log("")
@@ -494,7 +772,7 @@ async function collectCreateAppOptions(context, templates) {
       frontendDir,
       styling,
       installDependencies,
-      packageManager: resolvePackageManagerOption(context)
+      packageManager
     }
   })
 
@@ -503,7 +781,9 @@ async function collectCreateAppOptions(context, templates) {
     templateDir: path.join(frameworkPaths.templatesDir, selected.templateName),
     templateConfigPath: path.join(frameworkPaths.templatesDir, selected.templateName, "reset.config.json"),
     sourceFrontendDir: path.join(frameworkPaths.templatesDir, selected.templateName, "frontend"),
+    cliDependencySpec: resolveCliDependencySpec(frameworkPaths),
     sdkDependencySpec: resolveSdkDependencySpec(frameworkPaths),
+    packageManagerVersion: await resolvePackageManagerVersion(selected.packageManager),
     force: Boolean(context.flags.force)
   }
 }
@@ -542,6 +822,7 @@ export async function run(context) {
     ["App ID", options.appId],
     ["Frontend", options.frontendDir === "." ? "project root" : `${options.frontendDir}/`],
     ["Styling", options.styling],
+    ["Package manager", options.packageManager],
     ["Install", options.installDependencies ? describeInstallCommand(options.packageManager) : "skipped"]
   ])
 
@@ -553,10 +834,16 @@ export async function run(context) {
       ["plan", "Write README", path.join(options.targetDir, "README.md")],
       ["plan", "Write config", path.join(options.targetDir, "reset.config.json")],
       ["plan", "Write ignore file", path.join(options.targetDir, ".gitignore")],
+      ["plan", "Write app package", path.join(options.targetDir, "package.json")],
       ["plan", "Write SDK bridge", path.join(targetFrontendDir, "src", "lib", "reset.ts")],
       ["plan", "Write Vite config", path.join(targetFrontendDir, "vite.config.ts")],
       ["plan", "Write TS config", path.join(targetFrontendDir, "tsconfig.app.json")]
     ])
+    if (options.frontendDir !== ".") {
+      printStatusTable([
+        ["plan", "Write frontend runner", path.join(options.targetDir, "scripts", "run-frontend.mjs")]
+      ])
+    }
     if (options.styling === "tailwindcss") {
       printStatusTable([
         ["plan", "Patch package.json", path.join(targetFrontendDir, "package.json")],
@@ -566,14 +853,14 @@ export async function run(context) {
     }
     if (options.installDependencies) {
       printStatusTable([
-        ["plan", "Install dependencies", `${describeInstallCommand(options.packageManager)} in ${targetFrontendDir}`]
+        ["plan", "Install dependencies", `${describeInstallCommand(options.packageManager)} in ${options.targetDir}`]
       ])
     }
     return
   }
 
   console.log("")
-  const progress = createProgress(options.installDependencies ? 7 : 6, "Scaffold")
+  const progress = createProgress(options.installDependencies ? 6 : 5, "Scaffold")
 
   await mkdir(options.targetDir, { recursive: true })
   progress.tick("Prepared project directory")
@@ -581,20 +868,44 @@ export async function run(context) {
   await copyFrontendTemplate(options.sourceFrontendDir, targetFrontendDir, options)
   progress.tick("Copied frontend starter")
 
-  await cp(path.join(options.templateDir, "README.md"), path.join(options.targetDir, "README.md"), {
-    force: options.force
-  })
-  progress.tick("Wrote project README")
-
   await writeProjectFiles(options)
-  progress.tick("Wrote reset.config.json and root files")
+  await writeRootPackageFiles(options)
+  progress.tick("Wrote project files")
 
   await applyFrontendOverrides(targetFrontendDir, options)
   progress.tick("Applied frontend package wiring")
 
   const packageJsonPath = path.join(targetFrontendDir, "package.json")
   const frontendPackage = JSON.parse(await readFile(packageJsonPath, "utf8"))
-  frontendPackage.name = options.appName
+
+  if (options.frontendDir === ".") {
+    const currentScripts = { ...(frontendPackage.scripts ?? {}) }
+    frontendPackage.name = options.appName
+    frontendPackage.private = true
+    frontendPackage.version = "0.1.0"
+    frontendPackage.description = `${options.productName} desktop app`
+    frontendPackage.devDependencies = {
+      ...frontendPackage.devDependencies,
+      "reset-framework-cli": options.cliDependencySpec
+    }
+    frontendPackage.scripts = {
+      dev: "reset-framework-cli dev",
+      "dev:web": currentScripts.dev ?? "vite",
+      build: "reset-framework-cli build",
+      "build:web": currentScripts.build ?? "tsc -b && vite build",
+      package: "reset-framework-cli package",
+      doctor: "reset-framework-cli doctor",
+      lint: currentScripts.lint ?? "eslint .",
+      preview: currentScripts.preview ?? "vite preview"
+    }
+
+    if (options.packageManagerVersion) {
+      frontendPackage.packageManager = `${options.packageManager}@${options.packageManagerVersion}`
+    }
+  } else {
+    frontendPackage.name = `${options.appName}-frontend`
+  }
+
   await writeFile(packageJsonPath, JSON.stringify(frontendPackage, null, 2) + "\n", "utf8")
   progress.tick("Finalized starter metadata")
 
@@ -603,7 +914,7 @@ export async function run(context) {
       resolvePackageManagerCommand(options.packageManager),
       getInstallCommandArgs(options.packageManager),
       {
-        cwd: targetFrontendDir
+        cwd: options.targetDir
       }
     )
     progress.tick("Installed frontend dependencies")
@@ -613,6 +924,6 @@ export async function run(context) {
   printSection("Result")
   printStatusTable([
     ["done", "Project", options.targetDir],
-    ["done", "Next step", `cd ${formatTargetForShell(options.targetDir)} && reset-framework-cli dev`]
+    ["done", "Next step", `cd ${formatTargetForShell(options.targetDir)} && ${options.packageManager} run dev`]
   ])
 }

package/src/lib/process.js

@@ -82,6 +82,47 @@ export async function runCommand(command, args = [], options = {}) {
   })
 }
 
+export async function captureCommandOutput(command, args = [], options = {}) {
+  const { cwd, env } = options
+
+  await Promise.resolve()
+
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: env ? { ...process.env, ...env } : process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    })
+
+    let stdout = ""
+    let stderr = ""
+
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk)
+    })
+
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk)
+    })
+
+    child.once("error", reject)
+    child.once("exit", (code, signal) => {
+      if (code === 0) {
+        resolve(stdout.trim())
+        return
+      }
+
+      reject(
+        new Error(
+          signal
+            ? `Command terminated by signal: ${signal}`
+            : (stderr.trim() || stdout.trim() || `Command exited with code ${code}`)
+        )
+      )
+    })
+  })
+}
+
 export function spawnCommand(command, args = [], options = {}) {
   const { cwd, dryRun = false, env } = options
 

package/src/lib/project.js

@@ -88,6 +88,10 @@ function readJsonFile(filePath) {
   return JSON.parse(readFileSync(filePath, "utf8"))
 }
 
+function fileExists(filePath) {
+  return existsSync(filePath)
+}
+
 function isPathInside(parentDir, candidatePath) {
   const relative = path.relative(parentDir, candidatePath)
   return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative)
@@ -142,6 +146,8 @@ export function resolveFrameworkPaths() {
   const moduleDir = path.dirname(fileURLToPath(import.meta.url))
   const cliDir = path.resolve(moduleDir, "../..")
   const packagesDir = path.resolve(cliDir, "..")
+  const cliPackageJsonPath = path.join(cliDir, "package.json")
+  const cliManifest = readJsonFile(cliPackageJsonPath)
   const nativePackage = resolveWorkspacePackageInfo(
     "@reset-framework/native",
     path.join(packagesDir, "native"),
@@ -163,6 +169,13 @@ export function resolveFrameworkPaths() {
 
   return {
     cliDir,
+    cliPackage: {
+      packageName: cliManifest.name,
+      packageRoot: cliDir,
+      packageJsonPath: cliPackageJsonPath,
+      version: cliManifest.version ?? "0.0.0",
+      localFallback: true
+    },
     packagesDir,
     frameworkRoot: nativePackage.packageRoot,
     frameworkPackage: nativePackage,
@@ -207,6 +220,7 @@ export function resolveFrameworkBuildPaths(appPaths) {
 export function resolveAppPaths(appRoot) {
   return {
     appRoot,
+    appPackageJsonPath: path.join(appRoot, "package.json"),
     frontendDir: path.join(appRoot, "frontend"),
     resetConfigPath: path.join(appRoot, "reset.config.json"),
     legacyResetConfigPath: path.join(appRoot, "frontend", "reset.config.json")
@@ -388,3 +402,67 @@ export function resolveSdkDependencySpec(frameworkPaths) {
 
   return `^${frameworkPaths.sdkPackage.version}`
 }
+
+export function resolveCliDependencySpec(frameworkPaths) {
+  if (frameworkPaths.isWorkspaceLayout || frameworkPaths.cliPackage.localFallback) {
+    return `file:${frameworkPaths.cliPackage.packageRoot}`
+  }
+
+  return `^${frameworkPaths.cliPackage.version}`
+}
+
+function detectPackageManagerFromManifest(packageJsonPath) {
+  if (!fileExists(packageJsonPath)) {
+    return null
+  }
+
+  const manifest = readJsonFile(packageJsonPath)
+  const raw = typeof manifest.packageManager === "string" ? manifest.packageManager.trim() : ""
+  if (raw === "") {
+    return null
+  }
+
+  const [name] = raw.split("@")
+  if (name === "npm" || name === "pnpm" || name === "yarn" || name === "bun") {
+    return name
+  }
+
+  return null
+}
+
+function detectPackageManagerFromLocks(directory) {
+  if (!fileExists(directory)) {
+    return null
+  }
+
+  if (fileExists(path.join(directory, "bun.lock")) || fileExists(path.join(directory, "bun.lockb"))) {
+    return "bun"
+  }
+
+  if (fileExists(path.join(directory, "pnpm-lock.yaml"))) {
+    return "pnpm"
+  }
+
+  if (fileExists(path.join(directory, "yarn.lock"))) {
+    return "yarn"
+  }
+
+  if (fileExists(path.join(directory, "package-lock.json"))) {
+    return "npm"
+  }
+
+  return null
+}
+
+export function resolveAppPackageManager(appPaths, config) {
+  const frontendDir = resolveFrontendDir(appPaths, config)
+  const frontendPackageJsonPath = path.join(frontendDir, "package.json")
+
+  return (
+    detectPackageManagerFromManifest(appPaths.appPackageJsonPath) ??
+    detectPackageManagerFromManifest(frontendPackageJsonPath) ??
+    detectPackageManagerFromLocks(appPaths.appRoot) ??
+    detectPackageManagerFromLocks(frontendDir) ??
+    "npm"
+  )
+}