netlify-cli 15.9.1-rc.0 → 15.10.0-rc.0

package/src/commands/functions/functions-create.mjs

@@ -3,7 +3,7 @@ import cp from 'child_process'
 import fs from 'fs'
 import { mkdir, readdir, unlink } from 'fs/promises'
 import { createRequire } from 'module'
-import path, { dirname } from 'path'
+import path, { dirname, join, relative } from 'path'
 import process from 'process'
 import { fileURLToPath, pathToFileURL } from 'url'
 import { promisify } from 'util'
@@ -30,8 +30,10 @@ const templatesDir = path.resolve(dirname(fileURLToPath(import.meta.url)), '../.
 
 const showRustTemplates = process.env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE === 'true'
 
-// Ensure that there's a sub-directory in `src/functions-templates` named after
-// each `value` property in this list.
+/**
+ * Ensure that there's a sub-directory in `src/functions-templates` named after
+ * each `value` property in this list.
+ */
 const languages = [
   { name: 'JavaScript', value: 'javascript' },
   { name: 'TypeScript', value: 'typescript' },
@@ -90,23 +92,28 @@ const filterRegistry = function (registry, input) {
     })
 }
 
+/**
+ * @param {string} lang
+ * @param {'edge' | 'serverless'} funcType
+ */
 const formatRegistryArrayForInquirer = async function (lang, funcType) {
-  const folderNames = await readdir(path.join(templatesDir, lang))
+  const folders = await readdir(path.join(templatesDir, lang), { withFileTypes: true })
 
   const imports = await Promise.all(
-    folderNames
-      // filter out markdown files
-      .filter((folderName) => !folderName.endsWith('.md'))
-      .map(async (folderName) => {
-        const templatePath = path.join(templatesDir, lang, folderName, '.netlify-function-template.mjs')
-        const template = await import(pathToFileURL(templatePath))
-
-        return template.default
+    folders
+      .filter((folder) => Boolean(folder?.isDirectory()))
+      .map(async ({ name }) => {
+        try {
+          const templatePath = path.join(templatesDir, lang, name, '.netlify-function-template.mjs')
+          const template = await import(pathToFileURL(templatePath))
+          return template.default
+        } catch {
+          // noop if import fails we don't break the whole inquirer
+        }
       }),
   )
-
   const registry = imports
-    .filter((template) => template.functionType === funcType)
+    .filter((template) => template?.functionType === funcType)
     .sort((templateA, templateB) => {
       const priorityDiff = (templateA.priority || DEFAULT_PRIORITY) - (templateB.priority || DEFAULT_PRIORITY)
 
@@ -135,7 +142,7 @@ const formatRegistryArrayForInquirer = async function (lang, funcType) {
 /**
  * pick template from our existing templates
  * @param {import('commander').OptionValues} config
- *
+ * @param {'edge' | 'serverless'} funcType
  */
 const pickTemplate = async function ({ language: languageFromFlag }, funcType) {
   const specialCommands = [
@@ -204,6 +211,7 @@ const pickTemplate = async function ({ language: languageFromFlag }, funcType) {
 
 const DEFAULT_PRIORITY = 999
 
+/** @returns {Promise<'edge' | 'serverless'>} */
 const selectTypeOfFunc = async () => {
   const functionTypes = [
     { name: 'Edge function (Deno)', value: 'edge' },
@@ -221,92 +229,100 @@ const selectTypeOfFunc = async () => {
   return functionType
 }
 
+/**
+ * @param {import('../base-command.mjs').default} command
+ */
 const ensureEdgeFuncDirExists = function (command) {
   const { config, site } = command.netlify
   const siteId = site.id
-  let functionsDirHolder = config.build.edge_functions
 
   if (!siteId) {
     error(`${NETLIFYDEVERR} No site id found, please run inside a site directory or \`netlify link\``)
   }
 
-  if (!functionsDirHolder) {
-    functionsDirHolder = 'netlify/edge-functions'
-  }
+  const functionsDir = config.build?.edge_functions ?? join(command.workingDir, 'netlify/edge-functions')
+  const relFunctionsDir = relative(command.workingDir, functionsDir)
 
-  if (!fs.existsSync(functionsDirHolder)) {
+  if (!fs.existsSync(functionsDir)) {
     log(
       `${NETLIFYDEVLOG} Edge Functions directory ${chalk.magenta.inverse(
-        functionsDirHolder,
+        relFunctionsDir,
       )} does not exist yet, creating it...`,
     )
 
-    fs.mkdirSync(functionsDirHolder, { recursive: true })
+    fs.mkdirSync(functionsDir, { recursive: true })
 
-    log(`${NETLIFYDEVLOG} Edge Functions directory ${chalk.magenta.inverse(functionsDirHolder)} created.`)
+    log(`${NETLIFYDEVLOG} Edge Functions directory ${chalk.magenta.inverse(relFunctionsDir)} created.`)
   }
-  return functionsDirHolder
+
+  return functionsDir
 }
 
 /**
- * Get functions directory (and make it if necessary)
+ * Prompts the user to choose a functions directory
  * @param {import('../base-command.mjs').default} command
- * @returns {Promise<string|never>} - functions directory or throws an error
+ * @returns {Promise<string>} - functions directory or throws an error
  */
-const ensureFunctionDirExists = async function (command) {
-  const { api, config, site } = command.netlify
-  const siteId = site.id
-  let functionsDirHolder = config.functionsDirectory
-
-  if (!functionsDirHolder) {
-    log(`${NETLIFYDEVLOG} functions directory not specified in netlify.toml or UI settings`)
-
-    if (!siteId) {
-      error(`${NETLIFYDEVERR} No site id found, please run inside a site directory or \`netlify link\``)
-    }
+const promptFunctionsDirectory = async (command) => {
+  const { api, relConfigFilePath, site } = command.netlify
+  log(`\n${NETLIFYDEVLOG} functions directory not specified in ${relConfigFilePath} or UI settings`)
 
-    const { functionsDir } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'functionsDir',
-        message:
-          'Enter the path, relative to your site’s base directory in your repository, where your functions should live:',
-        default: 'netlify/functions',
-      },
-    ])
+  if (!site.id) {
+    error(`${NETLIFYDEVERR} No site id found, please run inside a site directory or \`netlify link\``)
+  }
 
-    functionsDirHolder = functionsDir
+  const { functionsDir } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'functionsDir',
+      message: 'Enter the path, relative to your site, where your functions should live:',
+      default: 'netlify/functions',
+    },
+  ])
 
-    try {
-      log(`${NETLIFYDEVLOG} updating site settings with ${chalk.magenta.inverse(functionsDirHolder)}`)
-
-      // @ts-ignore Typings of API are not correct
-      await api.updateSite({
-        siteId: site.id,
-        body: {
-          build_settings: {
-            functions_dir: functionsDirHolder,
-          },
+  try {
+    log(`${NETLIFYDEVLOG} updating site settings with ${chalk.magenta.inverse(functionsDir)}`)
+
+    // @ts-ignore Typings of API are not correct
+    await api.updateSite({
+      siteId: site.id,
+      body: {
+        build_settings: {
+          functions_dir: functionsDir,
         },
-      })
+      },
+    })
 
-      log(`${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(functionsDirHolder)} updated in site settings`)
-    } catch {
-      throw error('Error updating site settings')
-    }
+    log(`${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(functionsDir)} updated in site settings`)
+  } catch {
+    throw error('Error updating site settings')
   }
+  return functionsDir
+}
+
+/**
+ * Get functions directory (and make it if necessary)
+ * @param {import('../base-command.mjs').default} command
+ * @returns {Promise<string>} - functions directory or throws an error
+ */
+const ensureFunctionDirExists = async function (command) {
+  const { config } = command.netlify
+  const functionsDirHolder =
+    config.functionsDirectory || join(command.workingDir, await promptFunctionsDirectory(command))
+  const relFunctionsDirHolder = relative(command.workingDir, functionsDirHolder)
 
-  if (!(await fileExistsAsync(functionsDirHolder))) {
+  if (!fs.existsSync(functionsDirHolder)) {
     log(
       `${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(
-        functionsDirHolder,
+        relFunctionsDirHolder,
       )} does not exist yet, creating it...`,
     )
 
     await mkdir(functionsDirHolder, { recursive: true })
 
-    log(`${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(functionsDirHolder)} created`)
+    log(`${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(relFunctionsDirHolder)} created`)
   }
+
   return functionsDirHolder
 }
 
@@ -367,20 +383,24 @@ const downloadFromURL = async function (command, options, argumentName, function
   }
 }
 
-// Takes a list of existing packages and a list of packages required by a
-// function, and returns the packages from the latter that aren't present
-// in the former. The packages are returned as an array of strings with the
-// name and version range (e.g. '@netlify/functions@0.1.0').
+/**
+ * Takes a list of existing packages and a list of packages required by a
+ * function, and returns the packages from the latter that aren't present
+ * in the former. The packages are returned as an array of strings with the
+ * name and version range (e.g. '@netlify/functions@0.1.0').
+ */
 const getNpmInstallPackages = (existingPackages = {}, neededPackages = {}) =>
   Object.entries(neededPackages)
     .filter(([name]) => existingPackages[name] === undefined)
     .map(([name, version]) => `${name}@${version}`)
 
-// When installing a function's dependencies, we first try to find a site-level
-// `package.json` file. If we do, we look for any dependencies of the function
-// that aren't already listed as dependencies of the site and install them. If
-// we don't do this check, we may be upgrading the version of a module used in
-// another part of the project, which we don't want to do.
+/**
+ * When installing a function's dependencies, we first try to find a site-level
+ * `package.json` file. If we do, we look for any dependencies of the function
+ * that aren't already listed as dependencies of the site and install them. If
+ * we don't do this check, we may be upgrading the version of a module used in
+ * another part of the project, which we don't want to do.
+ */
 const installDeps = async ({ functionPackageJson, functionPath, functionsDir }) => {
   const { dependencies: functionDependencies, devDependencies: functionDevDependencies } = require(functionPackageJson)
   const sitePackageJson = await findUp('package.json', { cwd: functionsDir })
@@ -427,8 +447,8 @@ const installDeps = async ({ functionPackageJson, functionPath, functionsDir })
  * @param {import('../base-command.mjs').default} command
  * @param {import('commander').OptionValues} options
  * @param {string} argumentName
- * @param {string} functionsDir
- * @param {string} funcType
+ * @param {string} functionsDir Absolute path of the functions directory
+ * @param {'edge' | 'serverless'} funcType
  */
 // eslint-disable-next-line max-params
 const scaffoldFromTemplate = async function (command, options, argumentName, functionsDir, funcType) {
@@ -440,7 +460,7 @@ const scaffoldFromTemplate = async function (command, options, argumentName, fun
         name: 'chosenUrl',
         message: 'URL to clone: ',
         type: 'input',
-        validate: (val) => Boolean(validateRepoURL(val)),
+        validate: (/** @type {string} */ val) => Boolean(validateRepoURL(val)),
         // make sure it is not undefined and is a valid filename.
         // this has some nuance i have ignored, eg crossenv and i18n concerns
       },
@@ -503,7 +523,7 @@ const scaffoldFromTemplate = async function (command, options, argumentName, fun
     }
 
     if (funcType === 'edge') {
-      registerEFInToml(name)
+      registerEFInToml(name, command.netlify)
     }
 
     await installAddons(command, addons, path.resolve(functionPath))
@@ -628,9 +648,15 @@ const installAddons = async function (command, functionAddons, fnPath) {
   return Promise.all(arr)
 }
 
-const registerEFInToml = async (funcName) => {
-  if (!fs.existsSync('netlify.toml')) {
-    log(`${NETLIFYDEVLOG} \`netlify.toml\` file does not exist yet. Creating it...`)
+/**
+ *
+ * @param {string} funcName
+ * @param {import('../types.js').NetlifyOptions} options
+ */
+const registerEFInToml = async (funcName, options) => {
+  const { configFilePath, relConfigFilePath } = options
+  if (!fs.existsSync(configFilePath)) {
+    log(`${NETLIFYDEVLOG} \`${relConfigFilePath}\` file does not exist yet. Creating it...`)
   }
 
   let { funcPath } = await inquirer.prompt([
@@ -653,17 +679,22 @@ const registerEFInToml = async (funcName) => {
   const functionRegister = `\n\n[[edge_functions]]\nfunction = "${funcName}"\npath = "${funcPath}"`
 
   try {
-    fs.promises.appendFile('netlify.toml', functionRegister)
+    fs.promises.appendFile(configFilePath, functionRegister)
     log(
-      `${NETLIFYDEVLOG} Function '${funcName}' registered for route \`${funcPath}\`. To change, edit your \`netlify.toml\` file.`,
+      `${NETLIFYDEVLOG} Function '${funcName}' registered for route \`${funcPath}\`. To change, edit your \`${relConfigFilePath}\` file.`,
     )
   } catch {
-    error(`${NETLIFYDEVERR} Unable to register function. Please check your \`netlify.toml\` file.`)
+    error(`${NETLIFYDEVERR} Unable to register function. Please check your \`${relConfigFilePath}\` file.`)
   }
 }
 
-// we used to allow for a --dir command,
-// but have retired that to force every scaffolded function to be a directory
+/**
+ * we used to allow for a --dir command,
+ * but have retired that to force every scaffolded function to be a directory
+ * @param {string} functionsDir
+ * @param {string} name
+ * @returns
+ */
 const ensureFunctionPathIsOk = function (functionsDir, name) {
   const functionPath = path.join(functionsDir, name)
   if (fs.existsSync(functionPath)) {
@@ -675,6 +706,7 @@ const ensureFunctionPathIsOk = function (functionsDir, name) {
 
 /**
  * The functions:create command
+ * @param {string} name
  * @param {import('commander').OptionValues} options
  * @param {import('../base-command.mjs').default} command
  */

package/src/commands/functions/functions-invoke.mjs

@@ -144,11 +144,11 @@ const getFunctionToTrigger = function (options, argumentName) {
  * @param {import('../base-command.mjs').default} command
  */
 const functionsInvoke = async (nameArgument, options, command) => {
-  const { config } = command.netlify
+  const { config, relConfigFilePath } = command.netlify
 
   const functionsDir = options.functions || (config.dev && config.dev.functions) || config.functionsDirectory
   if (typeof functionsDir === 'undefined') {
-    error('functions directory is undefined, did you forget to set it in netlify.toml?')
+    error(`functions directory is undefined, did you forget to set it in ${relConfigFilePath}?`)
   }
 
   if (!options.port)

package/src/commands/functions/functions-list.mjs

@@ -16,7 +16,7 @@ const normalizeFunction = function (deployedFunctions, { name, urlPath: url }) {
  * @param {import('../base-command.mjs').default} command
  */
 const functionsList = async (options, command) => {
-  const { config, siteInfo } = command.netlify
+  const { config, relConfigFilePath, siteInfo } = command.netlify
 
   const deploy = siteInfo.published_deploy || {}
   const deployedFunctions = deploy.available_functions || []
@@ -25,7 +25,7 @@ const functionsList = async (options, command) => {
 
   if (typeof functionsDir === 'undefined') {
     log('Functions directory is undefined')
-    log('Please verify functions.directory is set in your Netlify configuration file (netlify.toml/yml/json)')
+    log(`Please verify functions.directory is set in your Netlify configuration file ${relConfigFilePath}`)
     log('See https://docs.netlify.com/configure-builds/file-based-configuration/ for more information')
     exit(1)
   }

package/src/commands/serve/serve.mjs

@@ -38,6 +38,7 @@ const serve = async (options, command) => {
   const devConfig = {
     ...(config.functionsDirectory && { functions: config.functionsDirectory }),
     ...(config.build.publish && { publish: config.build.publish }),
+
     ...config.dev,
     ...options,
     // Override the `framework` value so that we start a static server and not
@@ -69,8 +70,7 @@ const serve = async (options, command) => {
   // Netlify Build are loaded.
   await getInternalFunctionsDir({ base: site.root, ensureExists: true })
 
-  /** @type {Partial<import('../../utils/types.js').ServerSettings>} */
-  let settings = {}
+  let settings = /** @type {import('../../utils/types.js').ServerSettings} */ ({})
   try {
     settings = await detectServerSettings(devConfig, options, command)
 
@@ -88,11 +88,9 @@ const serve = async (options, command) => {
   )
 
   const { configPath: configPathOverride } = await runBuildTimeline({
-    cachedConfig,
-    options,
+    command,
     settings,
-    projectDir: command.workingDir,
-    site,
+    options,
   })
 
   await startFunctionsServer({

package/src/functions-templates/typescript/hello-world/package-lock.json

@@ -26,9 +26,9 @@
       }
     },
     "node_modules/@types/node": {
-      "version": "14.18.53",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.18.53.tgz",
-      "integrity": "sha512-soGmOpVBUq+gaBMwom1M+krC/NNbWlosh4AtGA03SyWNDiqSKtwp7OulO1M6+mg8YkHMvJ/y0AkCeO8d1hNb7A=="
+      "version": "14.18.54",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.18.54.tgz",
+      "integrity": "sha512-uq7O52wvo2Lggsx1x21tKZgqkJpvwCseBBPtX/nKQfpVlEsLOb11zZ1CRsWUKvJF0+lzuA9jwvA7Pr2Wt7i3xw=="
     },
     "node_modules/is-promise": {
       "version": "4.0.0",
@@ -58,9 +58,9 @@
       }
     },
     "@types/node": {
-      "version": "14.18.53",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.18.53.tgz",
-      "integrity": "sha512-soGmOpVBUq+gaBMwom1M+krC/NNbWlosh4AtGA03SyWNDiqSKtwp7OulO1M6+mg8YkHMvJ/y0AkCeO8d1hNb7A=="
+      "version": "14.18.54",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.18.54.tgz",
+      "integrity": "sha512-uq7O52wvo2Lggsx1x21tKZgqkJpvwCseBBPtX/nKQfpVlEsLOb11zZ1CRsWUKvJF0+lzuA9jwvA7Pr2Wt7i3xw=="
     },
     "is-promise": {
       "version": "4.0.0",

package/src/lib/edge-functions/bootstrap.mjs

@@ -1,5 +1,5 @@
 import { env } from 'process'
 
-const latestBootstrapURL = 'https://64ae60d920fd0f000865bcfc--edge.netlify.com/bootstrap/index-combined.ts'
+const latestBootstrapURL = 'https://64c264287e9cbb0008621df3--edge.netlify.com/bootstrap/index-combined.ts'
 
 export const getBootstrapURL = () => env.NETLIFY_EDGE_BOOTSTRAP || latestBootstrapURL

package/src/lib/edge-functions/headers.mjs

@@ -2,6 +2,7 @@
 import { Buffer } from 'buffer'
 
 export const headers = {
+  DeployID: 'x-nf-deploy-id',
   FeatureFlags: 'x-nf-feature-flags',
   ForwardedHost: 'x-forwarded-host',
   Functions: 'x-nf-edge-functions',

package/src/lib/edge-functions/proxy.mjs

@@ -139,6 +139,7 @@ export const initializeProxy = async ({
 
     // Setting header with geolocation and site info.
     req.headers[headers.Geo] = Buffer.from(JSON.stringify(geoLocation)).toString('base64')
+    req.headers[headers.DeployID] = '0'
     req.headers[headers.Site] = createSiteInfoHeader(siteInfo)
     req.headers[headers.Account] = createAccountInfoHeader({ id: accountId })
 

package/src/lib/functions/runtimes/js/index.mjs

@@ -3,7 +3,7 @@ import { dirname } from 'path'
 import { pathToFileURL } from 'url'
 import { Worker } from 'worker_threads'
 
-import lambdaLocal from '@skn0tt/lambda-local'
+import lambdaLocal from 'lambda-local'
 import winston from 'winston'
 
 import detectNetlifyLambdaBuilder from './builders/netlify-lambda.mjs'

package/src/lib/functions/runtimes/js/worker.mjs

@@ -1,8 +1,8 @@
 import { createServer } from 'net'
 import { isMainThread, workerData, parentPort } from 'worker_threads'
 
-import lambdaLocal from '@skn0tt/lambda-local'
 import { isStream } from 'is-stream'
+import lambdaLocal from 'lambda-local'
 import sourceMapSupport from 'source-map-support'
 
 if (isMainThread) {

package/src/recipes/vscode/index.mjs

@@ -1,3 +1,4 @@
+// @ts-check
 import { join } from 'path'
 
 import { DenoBridge } from '@netlify/edge-bundler'
@@ -27,15 +28,24 @@ const getPrompt = ({ fileExists, path }) => {
 const getEdgeFunctionsPath = ({ config, repositoryRoot }) =>
   config.build.edge_functions || join(repositoryRoot, 'netlify', 'edge-functions')
 
+/**
+ * @param {string} repositoryRoot
+ */
 const getSettingsPath = (repositoryRoot) => join(repositoryRoot, '.vscode', 'settings.json')
 
-const hasDenoVSCodeExt = async () => {
-  const { stdout: extensions } = await execa('code', ['--list-extensions'], { stderr: 'inherit' })
+/**
+ * @param {string} repositoryRoot
+ */
+const hasDenoVSCodeExt = async (repositoryRoot) => {
+  const { stdout: extensions } = await execa('code', ['--list-extensions'], { stderr: 'inherit', cwd: repositoryRoot })
   return extensions.split('\n').includes('denoland.vscode-deno')
 }
 
-const getDenoVSCodeExt = async () => {
-  await execa('code', ['--install-extension', 'denoland.vscode-deno'], { stdio: 'inherit' })
+/**
+ * @param {string} repositoryRoot
+ */
+const getDenoVSCodeExt = async (repositoryRoot) => {
+  await execa('code', ['--install-extension', 'denoland.vscode-deno'], { stdio: 'inherit', cwd: repositoryRoot })
 }
 
 const getDenoExtPrompt = () => {
@@ -49,6 +59,12 @@ const getDenoExtPrompt = () => {
   })
 }
 
+/**
+ * @param {object} params
+ * @param {*} params.config
+ * @param {string} params.repositoryRoot
+ * @returns
+ */
 export const run = async ({ config, repositoryRoot }) => {
   const deno = new DenoBridge({
     onBeforeDownload: () =>
@@ -66,9 +82,11 @@ export const run = async ({ config, repositoryRoot }) => {
   }
 
   try {
-    if (!(await hasDenoVSCodeExt())) {
+    if (!(await hasDenoVSCodeExt(repositoryRoot))) {
       const { confirm: denoExtConfirm } = await getDenoExtPrompt()
-      if (denoExtConfirm) getDenoVSCodeExt()
+      if (denoExtConfirm) {
+        getDenoVSCodeExt(repositoryRoot)
+      }
     }
   } catch {
     log(

package/src/utils/build-info.mjs

@@ -1,5 +1,86 @@
 // @ts-check
 
+import fuzzy from 'fuzzy'
+import inquirer from 'inquirer'
+
+import { chalk, log } from './command-helpers.mjs'
+
+/**
+ * Filters the inquirer settings based on the input
+ * @param {ReturnType<typeof formatSettingsArrForInquirer>} scriptInquirerOptions
+ * @param {string} input
+ */
+const filterSettings = function (scriptInquirerOptions, input) {
+  const filterOptions = scriptInquirerOptions.map((scriptInquirerOption) => scriptInquirerOption.name)
+  // TODO: remove once https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1394 is fixed
+  // eslint-disable-next-line unicorn/no-array-method-this-argument
+  const filteredSettings = fuzzy.filter(input, filterOptions)
+  const filteredSettingNames = new Set(
+    filteredSettings.map((filteredSetting) => (input ? filteredSetting.string : filteredSetting)),
+  )
+  return scriptInquirerOptions.filter((t) => filteredSettingNames.has(t.name))
+}
+
+/** @typedef {import('@netlify/build-info').Settings} Settings */
+
+/**
+ * @param {Settings[]} settings
+ * @param {'dev' | 'build'} type The type of command (dev or build)
+ */
+const formatSettingsArrForInquirer = function (settings, type = 'dev') {
+  return settings.map((setting) => {
+    const cmd = type === 'dev' ? setting.devCommand : setting.buildCommand
+    return {
+      name: `[${chalk.yellow(setting.framework.name)}] '${cmd}'`,
+      value: { ...setting, commands: [cmd] },
+      short: `${setting.name}-${cmd}`,
+    }
+  })
+}
+
+/**
+ * Uses @netlify/build-info to detect the dev settings and port based on the framework
+ * and the build system that is used.
+ * @param {import('../commands/base-command.mjs').default} command
+ * @param {'dev' | 'build'} type The type of command (dev or build)
+ * @returns {Promise<Settings | undefined>}
+ */
+export const detectFrameworkSettings = async (command, type = 'dev') => {
+  const { relConfigFilePath } = command.netlify
+  const settings = await detectBuildSettings(command)
+  if (settings.length === 1) {
+    return settings[0]
+  }
+
+  if (settings.length > 1) {
+    /** multiple matching detectors, make the user choose */
+    const scriptInquirerOptions = formatSettingsArrForInquirer(settings, type)
+    /** @type {{chosenSettings: Settings}} */
+    const { chosenSettings } = await inquirer.prompt({
+      name: 'chosenSettings',
+      message: `Multiple possible ${type} commands found`,
+      type: 'autocomplete',
+      source(/** @type {string} */ _, input = '') {
+        if (!input) return scriptInquirerOptions
+        // only show filtered results
+        return filterSettings(scriptInquirerOptions, input)
+      },
+    })
+
+    log(`
+Update your ${relConfigFilePath} to avoid this selection prompt next time:
+
+[build]
+command = "${chosenSettings.buildCommand}"
+publish = "${chosenSettings.dist}"
+
+[dev]
+command = "${chosenSettings.devCommand}"
+`)
+    return chosenSettings
+  }
+}
+
 /**
  * Detects and filters the build setting for a project and a command
  * @param {import('../commands/base-command.mjs').default} command