@sanity/cli 3.93.1-next.9.198ab74452 → 3.94.0

package/src/commands/typegen/generateTypesCommand.ts

@@ -1,56 +0,0 @@
-import {type CliCommandDefinition} from '../../types'
-
-const description = 'Generates TypeScript types from schema types and GROQ queries'
-
-const helpText = `
-Sanity TypeGen (Beta)
-This command is currently in beta and may undergo significant changes. Feedback is welcome!
-
-Usage
-  sanity typegen generate [options]
-
-Options:
-  --config-path <path>
-    Specifies the path to the typegen configuration file. This file should be a JSON file that contains settings for the type generation process.
-    Default: "sanity-typegen.json"
-
-  --help, -h
-    Displays this help message, providing information on command usage and options.
-
-Examples:
-  Generate TypeScript type definitions from a Sanity Studio schema extracted using the \`sanity schema extract\` command.
-    $ sanity typegen generate
-
-Configuration:
-This command can utilize configuration settings defined in a \`sanity-typegen.json\` file. These settings include:
-
-- "path": Specifies a glob pattern to locate your TypeScript or JavaScript files.
-  Default: "./src/**/*.{ts,tsx,js,jsx}"
-
-- "schema": Defines the path to your Sanity schema file. This file should be generated using the \`sanity schema extract\` command.
-  Default: "schema.json"
-
-- "generates": Indicates the path where the generated TypeScript type definitions will be saved.
-  Default: "./sanity.types.ts"
-
-The default configuration values listed above are used if not overridden in your \`sanity-typegen.json\` configuration file. To customize the behavior of the type generation, adjust these properties in the configuration file according to your project's needs.
-
-Note:
-- The \`sanity schema extract\` command is a prerequisite for extracting your Sanity Studio schema into a \`schema.json\` file, which is then used by the \`sanity typegen generate\` command to generate type definitions.
-- While this tool is in beta, we encourage you to experiment with these configurations and provide feedback to help improve its functionality and usability.
-`
-
-const generateTypegenCommand: CliCommandDefinition = {
-  name: 'generate',
-  group: 'typegen',
-  signature: '',
-  description,
-  helpText,
-  action: async (args, context) => {
-    const mod = await import('../../actions/typegen/generateAction')
-
-    return mod.default(args, context)
-  },
-} satisfies CliCommandDefinition
-
-export default generateTypegenCommand

package/src/commands/typegen/typegenGroup.ts

@@ -1,10 +0,0 @@
-import {type CliCommandGroupDefinition} from '../../types'
-
-const typegenGroup: CliCommandGroupDefinition = {
-  name: 'typegen',
-  signature: '[COMMAND]',
-  isGroupRoot: true,
-  description: 'Beta: Generate TypeScript types for schema and GROQ',
-}
-
-export default typegenGroup

package/src/commands/versions/printVersionResult.ts

@@ -1,51 +0,0 @@
-import chalk from 'chalk'
-import {padEnd, padStart} from 'lodash'
-
-import {
-  findSanityModuleVersions,
-  type ModuleVersionResult,
-} from '../../actions/versions/findSanityModuleVersions'
-import {type CliCommandAction} from '../../types'
-
-const printVersionResultCommand: CliCommandAction = async (args, context) => {
-  const versions = await findSanityModuleVersions(context, {target: 'latest'})
-  printResult(versions, context.output.print)
-}
-
-export default printVersionResultCommand
-
-export function printResult(versions: ModuleVersionResult[], print: (msg: string) => void): void {
-  const {versionLength, formatName} = getFormatters(versions)
-  versions.forEach((mod) => {
-    const version = padStart(mod.installed || '<missing>', versionLength)
-    const latest =
-      mod.installed === mod.latest
-        ? chalk.green('(up to date)')
-        : `(latest: ${chalk.yellow(mod.latest)})`
-
-    print(`${formatName(getDisplayName(mod))} ${version} ${latest}`)
-  })
-}
-
-export function getFormatters(versions: ModuleVersionResult[]): {
-  nameLength: number
-  versionLength: number
-  formatName: (name: string) => string
-} {
-  const nameLength = versions.reduce((max, mod) => Math.max(max, getDisplayName(mod).length), 0)
-  const versionLength = versions.reduce(
-    (max, mod) => Math.max(max, (mod.installed || '<missing>').length),
-    0,
-  )
-
-  const formatName = (name: string): string =>
-    padEnd(name, nameLength + 1)
-      .replace(/^@sanity\/(.*?)(\s|$)/, `${chalk.yellow('@sanity/')}${chalk.cyan('$1')}$2`)
-      .replace(/^sanity(\s|$)/, `${chalk.yellow('sanity')}$1`)
-
-  return {nameLength, versionLength, formatName}
-}
-
-function getDisplayName(mod: ModuleVersionResult): string {
-  return mod.isGlobal ? `${mod.name} (global)` : mod.name
-}

package/src/commands/versions/versionsCommand.ts

@@ -1,13 +0,0 @@
-import printVersionResult from './printVersionResult'
-
-const help = `
-Shows a list of installed Sanity modules and their respective versions, and
-checks the npm registry for the latest available versions.`
-
-export default {
-  name: 'versions',
-  signature: '',
-  description: 'Shows installed versions of Sanity Studio and components',
-  helpText: help,
-  action: printVersionResult,
-}

package/src/config.ts

@@ -1,14 +0,0 @@
-import {type CliConfig} from './types'
-
-/** @beta */
-export function defineCliConfig(config: CliConfig): CliConfig {
-  return config
-}
-
-/**
- * @deprecated Use `defineCliConfig` instead
- * @beta
- */
-export function createCliConfig(config: CliConfig): CliConfig {
-  return config
-}

package/src/debug.ts

@@ -1,3 +0,0 @@
-import debugIt from 'debug'
-
-export const debug = debugIt('sanity:cli')

package/src/index.ts

@@ -1,6 +0,0 @@
-export type {CliClientOptions} from './cliClient'
-export {getCliClient} from './cliClient'
-export * from './config'
-export * from './types'
-export {loadEnv} from './util/loadEnv'
-export type {SanityClient} from '@sanity/client'

package/src/outputters/cliOutputter.ts

@@ -1,47 +0,0 @@
-/* eslint-disable no-console */
-import chalk from 'chalk'
-import ora, {type Options, type Ora} from 'ora'
-
-const SYMBOL_CHECK = chalk.green('✓')
-const SYMBOL_WARN = chalk.yellow('⚠')
-const SYMBOL_FAIL = chalk.red('✗')
-
-let isFirstClear = true
-
-export default {
-  print(...args: unknown[]): void {
-    console.log(...args)
-  },
-
-  success(firstPartOfMessage: unknown, ...args: unknown[]): void {
-    console.log(`${SYMBOL_CHECK} ${firstPartOfMessage}`, ...args)
-  },
-
-  warn(firstPartOfMessage: unknown, ...args: unknown[]): void {
-    console.warn(`${SYMBOL_WARN} ${firstPartOfMessage}`, ...args)
-  },
-
-  error(firstPartOfMessage: unknown, ...args: unknown[]): void {
-    if (firstPartOfMessage instanceof Error) {
-      console.error(`${SYMBOL_FAIL} ${chalk.red(firstPartOfMessage.stack)}`)
-    } else {
-      console.error(`${SYMBOL_FAIL} ${firstPartOfMessage}`, ...args)
-    }
-  },
-
-  clear: (): void => {
-    // On first run, clear completely so it doesn't show half screen on Windows.
-    // On next runs, use a different sequence that properly scrolls back.
-    process.stdout.write(isFirstClear ? '\x1bc' : '\x1b[2J\x1b[0f')
-    isFirstClear = false
-  },
-
-  spinner(options: Options): Ora {
-    const spinner = ora(options)
-    // Override the default status methods to use custom symbols instead of emojis
-    spinner.succeed = (text?: string) => spinner.stopAndPersist({text, symbol: SYMBOL_CHECK})
-    spinner.warn = (text?: string) => spinner.stopAndPersist({text, symbol: SYMBOL_WARN})
-    spinner.fail = (text?: string) => spinner.stopAndPersist({text, symbol: SYMBOL_FAIL})
-    return spinner
-  },
-}

package/src/packageManager/getInstallCommand.ts

@@ -1,26 +0,0 @@
-import {getPackageManagerChoice} from './packageManagerChoice'
-
-export async function getInstallCommand(options: {
-  workDir: string
-  pkgNames?: string[]
-  depType?: 'dev' | 'prod' | 'peer'
-}): Promise<string> {
-  const {workDir, depType = 'prod', pkgNames} = options
-  const {chosen} = await getPackageManagerChoice(workDir, {interactive: false})
-
-  // eg `npm install`, `yarn install`, `pnpm install`
-  if (!pkgNames || pkgNames.length === 0) {
-    return `${chosen} install`
-  }
-
-  const pkgNameString = pkgNames.join(' ')
-
-  if (chosen === 'yarn') {
-    const flag = depType === 'dev' || depType === 'peer' ? ` --${depType}` : ''
-    return `yarn add ${pkgNameString}${flag}`
-  } else if (chosen === 'pnpm') {
-    return `pnpm add ${pkgNameString} --save-${depType}`
-  }
-
-  return `npm install ${pkgNameString} --save-${depType}`
-}

package/src/packageManager/getUpgradeCommand.ts

@@ -1,52 +0,0 @@
-import path from 'node:path'
-
-import isInstalledGlobally from 'is-installed-globally'
-
-import {debug} from '../debug'
-import {getPackageManagerChoice} from './packageManagerChoice'
-
-const cliPkgName = '@sanity/cli'
-
-interface Options {
-  cwd?: string
-  workDir?: string
-}
-
-export async function getCliUpgradeCommand(options: Options = {}): Promise<string> {
-  let {cwd, workDir} = options
-  cwd = path.resolve(cwd || process.cwd())
-  workDir = path.resolve(workDir || cwd)
-
-  if (isInstalledGlobally && isInstalledUsingYarn()) {
-    debug('CLI is installed globally with yarn')
-    return `yarn global add ${cliPkgName}`
-  }
-
-  if (isInstalledGlobally) {
-    debug('CLI is installed globally with npm')
-    return `npm install -g ${cliPkgName}`
-  }
-
-  const cmds = cwd === workDir ? [] : [`cd ${path.relative(cwd, workDir)}`]
-
-  const {chosen} = await getPackageManagerChoice(workDir, {interactive: false})
-
-  if (chosen === 'yarn') {
-    cmds.push(`yarn upgrade ${cliPkgName}`)
-  } else if (chosen === 'pnpm') {
-    cmds.push(`pnpm update ${cliPkgName}`)
-  } else {
-    cmds.push(`npm update ${cliPkgName}`)
-  }
-
-  return cmds.join(' && ')
-}
-
-function isInstalledUsingYarn() {
-  const isWindows = process.platform === 'win32'
-  const yarnPath = isWindows
-    ? path.join('Yarn', 'config', 'global')
-    : path.join('.config', 'yarn', 'global')
-
-  return __dirname.includes(yarnPath)
-}

package/src/packageManager/index.ts

@@ -1,33 +0,0 @@
-import {getInstallCommand} from './getInstallCommand'
-import {getCliUpgradeCommand} from './getUpgradeCommand'
-import {installDeclaredPackages, installNewPackages} from './installPackages'
-import {getPackageManagerChoice} from './packageManagerChoice'
-import {uninstallPackages} from './uninstallPackages'
-import {getYarnStub} from './yarnStub'
-
-// Exported for internal CLI usage
-export {
-  getCliUpgradeCommand,
-  getInstallCommand,
-  getPackageManagerChoice,
-  getYarnStub,
-  installDeclaredPackages,
-  installNewPackages,
-  uninstallPackages,
-}
-
-// Exported for use in `sanity` (formerly `@sanity/core`)
-
-/**
- * @internal
- */
-export const cliPackageManager = {
-  getInstallCommand,
-  getPackageManagerChoice,
-  installNewPackages,
-}
-
-/**
- * @internal
- */
-export type CliPackageManager = typeof cliPackageManager

package/src/packageManager/installPackages.ts

@@ -1,99 +0,0 @@
-import execa, {type CommonOptions, type ExecaReturnValue} from 'execa'
-
-import {type CliCommandContext} from '../types'
-import {getPartialEnvWithNpmPath, type PackageManager} from './packageManagerChoice'
-
-export interface InstallOptions {
-  packageManager: PackageManager
-  packages: string[]
-}
-
-export async function installDeclaredPackages(
-  cwd: string,
-  packageManager: PackageManager,
-  context: Pick<CliCommandContext, 'output'>,
-): Promise<void> {
-  const {output} = context
-  const execOptions: CommonOptions<'utf8'> = {
-    encoding: 'utf8',
-    env: getPartialEnvWithNpmPath(cwd),
-    cwd,
-    stdio: 'pipe',
-  }
-
-  // results of running execa with the selected package manager
-  let result: ExecaReturnValue<string> | undefined
-
-  type PackageManagerLibs = Exclude<PackageManager, 'manual'>
-  type InstallerArgs = {[key in PackageManagerLibs]: string[]}
-
-  const installerArgs: InstallerArgs = {
-    npm: ['install', '--legacy-peer-deps'],
-    yarn: ['install'],
-    pnpm: ['install'],
-    bun: ['install'],
-  }
-
-  async function handleInstall(cmd: PackageManager, args: InstallerArgs[PackageManagerLibs]) {
-    // Start a spinner for the install process
-    const progress = output.spinner(`Running ${cmd} ${args.join(' ')}\n`).start()
-
-    // Perform the install command with execa
-    result = await execa(cmd, args, execOptions)
-
-    // If the install fails, log execa's stdout and throw…
-    if (result?.exitCode || result?.failed) {
-      progress.fail()
-      output.print(result.stdout)
-      throw new Error('Dependency installation failed')
-    } else {
-      // …otherwise, just mark the install as successful
-      progress.succeed()
-    }
-  }
-
-  if (packageManager === 'manual') {
-    output.print(`Manual installation selected — run 'npm ${installerArgs.npm} or equivalent'`)
-  } else {
-    await handleInstall(packageManager, installerArgs[packageManager])
-  }
-}
-
-export async function installNewPackages(
-  options: InstallOptions,
-  context: Pick<CliCommandContext, 'output' | 'workDir'>,
-): Promise<void> {
-  const {packageManager, packages} = options
-  const {output, workDir} = context
-  const execOptions: CommonOptions<'utf8'> = {
-    encoding: 'utf8',
-    env: getPartialEnvWithNpmPath(workDir),
-    cwd: workDir,
-    stdio: 'inherit',
-  }
-
-  const npmArgs = ['install', '--legacy-peer-deps', '--save', ...packages]
-  let result: ExecaReturnValue<string> | undefined
-  if (packageManager === 'npm') {
-    output.print(`Running 'npm ${npmArgs.join(' ')}'`)
-    result = await execa('npm', npmArgs, execOptions)
-  } else if (packageManager === 'yarn') {
-    const yarnArgs = ['add', ...packages]
-    output.print(`Running 'yarn ${yarnArgs.join(' ')}'`)
-    result = await execa('yarn', yarnArgs, execOptions)
-  } else if (packageManager === 'pnpm') {
-    const pnpmArgs = ['add', '--save-prod', ...packages]
-    output.print(`Running 'pnpm ${pnpmArgs.join(' ')}'`)
-    result = await execa('pnpm', pnpmArgs, execOptions)
-  } else if (packageManager === 'bun') {
-    const bunArgs = ['add', ...packages]
-    output.print(`Running 'bun ${bunArgs.join(' ')}'`)
-    result = await execa('bun', bunArgs, execOptions)
-  } else if (packageManager === 'manual') {
-    output.print(`Manual installation selected - run 'npm ${npmArgs.join(' ')}' or equivalent`)
-  }
-
-  if (result?.exitCode || result?.failed) {
-    throw new Error('Package installation failed')
-  }
-}

package/src/packageManager/packageManagerChoice.ts

@@ -1,204 +0,0 @@
-/* eslint-disable no-process-env */
-import path from 'node:path'
-
-import preferredPM from 'preferred-pm'
-import which from 'which'
-
-import {type CliPrompter} from '../types'
-import {isInteractive} from '../util/isInteractive'
-
-export type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'manual'
-
-export const ALLOWED_PACKAGE_MANAGERS: PackageManager[] = ['npm', 'yarn', 'pnpm', 'bun', 'manual']
-export const allowedPackageManagersString = ALLOWED_PACKAGE_MANAGERS.map((pm) => `"${pm}"`).join(
-  ' | ',
-)
-
-const EXPERIMENTAL = ['bun']
-
-/**
- * Attempts to resolve the most optimal package manager to use to install/upgrade
- * packages/dependencies at a given path. It does so by looking for package manager
- * specific lockfiles. If it finds a lockfile belonging to a certain package manager,
- * it prioritizes this one. However, if that package manager is not installed, it will
- * prompt the user for which one they want to use and hint at the most optimal one
- * not being installed.
- *
- * Note that this function also takes local npm binary paths into account - for instance,
- * `yarn` can be installed as a dependency of the project instead of globally, and it
- * will use that is available.
- *
- * The user can also select 'manual' to skip the process and run their preferred package
- * manager manually. Commands using this function must take this `manual` choice into
- * account and act accordingly if chosen.
- *
- * @param workDir - The working directory where a lockfile is most likely to be present
- * @param options - Pass `interactive: false` to fall back to npm if most optimal is
- *                  not available, instead of prompting
- * @returns Object of `chosen` and, if a lockfile is found, the `mostOptimal` choice
- */
-export async function getPackageManagerChoice(
-  workDir: string,
-  options: {interactive: false} | {interactive?: true; prompt: CliPrompter},
-): Promise<{chosen: PackageManager; mostOptimal?: PackageManager}> {
-  const rootDir = workDir || process.cwd()
-  const preferred = (await preferredPM(rootDir))?.name
-
-  if (preferred && (await hasCommand(preferred, rootDir))) {
-    // There is an optimal/preferred package manager, and the user has it installed!
-    return {chosen: preferred, mostOptimal: preferred}
-  }
-
-  const mostLikelyPM = await getMostLikelyInstalledPackageManager(rootDir)
-  const interactive = typeof options.interactive === 'boolean' ? options.interactive : isInteractive
-  if (!interactive) {
-    // We can't ask the user for their preference, so fall back to either the one that is being run
-    // or whatever is installed on the system (npm being the preferred choice).
-    // Note that the most optimal choice is already picked above if available.
-    return {chosen: mostLikelyPM || (await getFallback(rootDir)), mostOptimal: preferred}
-  }
-
-  if (!('prompt' in options)) {
-    throw new Error('Must pass `prompt` when in interactive mode')
-  }
-
-  // We can ask the user for their preference, hurray!
-  const messageSuffix = preferred ? ` (preferred is ${preferred}, but is not installed)` : ''
-  const installed = await getAvailablePackageManagers(rootDir)
-  const chosen = await options.prompt.single<PackageManager>({
-    type: 'list',
-    choices: installed.map((pm) => ({
-      value: pm,
-      name: EXPERIMENTAL.includes(pm) ? `${pm} (experimental)` : pm,
-    })),
-    default: preferred || mostLikelyPM,
-    message: `Package manager to use for installing dependencies?${messageSuffix}`,
-  })
-
-  return {chosen, mostOptimal: preferred}
-}
-
-async function getFallback(cwd: string): Promise<PackageManager> {
-  if (await hasNpmInstalled(cwd)) {
-    return 'npm'
-  }
-
-  if (await hasYarnInstalled(cwd)) {
-    return 'yarn'
-  }
-
-  if (await hasPnpmInstalled(cwd)) {
-    return 'pnpm'
-  }
-
-  if (await hasBunInstalled(cwd)) {
-    return 'bun'
-  }
-
-  return 'manual'
-}
-
-async function getAvailablePackageManagers(cwd: string): Promise<PackageManager[]> {
-  const [npm, yarn, pnpm, bun] = await Promise.all([
-    hasNpmInstalled(cwd),
-    hasYarnInstalled(cwd),
-    hasPnpmInstalled(cwd),
-    hasBunInstalled(cwd),
-  ])
-
-  const choices = [npm && 'npm', yarn && 'yarn', pnpm && 'pnpm', bun && 'bun', 'manual']
-  return choices.filter((pm): pm is PackageManager => pm !== false)
-}
-
-export function hasNpmInstalled(cwd?: string): Promise<boolean> {
-  return hasCommand('npm', cwd)
-}
-
-export function hasYarnInstalled(cwd?: string): Promise<boolean> {
-  return hasCommand('yarn', cwd)
-}
-
-export function hasPnpmInstalled(cwd?: string): Promise<boolean> {
-  return hasCommand('pnpm', cwd)
-}
-
-export function hasBunInstalled(cwd?: string): Promise<boolean> {
-  return hasCommand('bun', cwd)
-}
-
-export function getNpmRunPath(cwd: string): string {
-  let previous
-  let cwdPath = path.resolve(cwd)
-  const result: string[] = []
-
-  while (previous !== cwdPath) {
-    result.push(path.join(cwdPath, 'node_modules', '.bin'))
-    previous = cwdPath
-    cwdPath = path.resolve(cwdPath, '..')
-  }
-
-  result.push(path.resolve(cwd, process.execPath, '..'))
-
-  const pathEnv = process.env[getPathEnvVarKey()]
-  return [...result, pathEnv].join(path.delimiter)
-}
-
-export function getPartialEnvWithNpmPath(cwd: string): NodeJS.ProcessEnv {
-  const key = getPathEnvVarKey()
-  return {[key]: getNpmRunPath(cwd)}
-}
-
-function getPathEnvVarKey(): string {
-  if (process.platform !== 'win32') {
-    return 'PATH'
-  }
-
-  return (
-    Object.keys(process.env)
-      .reverse()
-      .find((key) => key.toUpperCase() === 'PATH') || 'Path'
-  )
-}
-
-function getCommandPath(cmd: string, cwd?: string): Promise<string | null> {
-  const options = cwd ? {path: getNpmRunPath(cwd)} : {}
-  return which(cmd, options).catch(() => null)
-}
-
-function hasCommand(cmd: string, cwd?: string): Promise<boolean> {
-  return getCommandPath(cmd, cwd).then((cmdPath) => cmdPath !== null)
-}
-
-async function getMostLikelyInstalledPackageManager(
-  rootDir: string,
-): Promise<PackageManager | undefined> {
-  const installed = await getAvailablePackageManagers(rootDir)
-  const running = getRunningPackageManager()
-  return running && installed.includes(running) ? running : undefined
-}
-
-function getRunningPackageManager(): PackageManager | undefined {
-  // 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
-}

package/src/packageManager/uninstallPackages.ts

@@ -1,44 +0,0 @@
-import execa, {type CommonOptions, type ExecaReturnValue} from 'execa'
-
-import {type CliCommandContext} from '../types'
-import {getPartialEnvWithNpmPath, type PackageManager} from './packageManagerChoice'
-
-export interface UninstallOptions {
-  packageManager: PackageManager
-  packages: string[]
-}
-
-export async function uninstallPackages(
-  options: UninstallOptions,
-  context: Pick<CliCommandContext, 'output' | 'workDir'>,
-): Promise<void> {
-  const {packageManager, packages} = options
-  const {output, workDir} = context
-  const execOptions: CommonOptions<'utf8'> = {
-    encoding: 'utf8',
-    env: getPartialEnvWithNpmPath(workDir),
-    cwd: workDir,
-    stdio: 'inherit',
-  }
-
-  const npmArgs = ['uninstall', ...packages]
-  let result: ExecaReturnValue<string> | undefined
-  if (packageManager === 'npm') {
-    output.print(`Running 'npm ${npmArgs.join(' ')}'`)
-    result = await execa('npm', npmArgs, execOptions)
-  } else if (packageManager === 'yarn') {
-    const yarnArgs = ['remove', ...packages]
-    output.print(`Running 'yarn ${yarnArgs.join(' ')}'`)
-    result = await execa('yarn', yarnArgs, execOptions)
-  } else if (packageManager === 'pnpm') {
-    const pnpmArgs = ['remove', ...packages]
-    output.print(`Running 'pnpm ${pnpmArgs.join(' ')}'`)
-    result = await execa('pnpm', pnpmArgs, execOptions)
-  } else if (packageManager === 'manual') {
-    output.print(`Manual installation selected - run 'npm ${npmArgs.join(' ')}' or equivalent`)
-  }
-
-  if (result?.exitCode || result?.failed) {
-    throw new Error('Package installation failed')
-  }
-}