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

package/src/utils/detect-server-settings.mjs

@@ -4,11 +4,9 @@ import { EOL } from 'os'
 import { dirname, relative, resolve } from 'path'
 
 import { getFramework, getSettings } from '@netlify/build-info'
-import fuzzy from 'fuzzy'
 import getPort from 'get-port'
-import inquirer from 'inquirer'
 
-import { detectBuildSettings } from './build-info.mjs'
+import { detectFrameworkSettings } from './build-info.mjs'
 import { NETLIFYDEVWARN, chalk, log } from './command-helpers.mjs'
 import { acquirePort } from './dev.mjs'
 import { getInternalFunctionsDir } from './functions/functions.mjs'
@@ -175,53 +173,22 @@ const handleStaticServer = async ({ devConfig, flags, workingDir }) => {
 
 /**
  * Retrieves the settings from a framework
- * @param {import('@netlify/build-info').Settings} settings
- * @returns {import('./types.js').BaseServerSettings}
- */
-const getSettingsFromDetectedSettings = (settings) => ({
-  command: settings.devCommand,
-  frameworkPort: settings.frameworkPort,
-  dist: settings.dist,
-  framework: settings.framework.name,
-  env: settings.env,
-  pollingStrategies: settings.pollingStrategies,
-  plugins: getPluginsToAutoInstall(settings.plugins_from_config_file, settings.plugins_recommended),
-})
-
-/**
- * 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 {import('@netlify/build-info').Settings} [settings]
+ * @returns {import('./types.js').BaseServerSettings | undefined}
  */
-const detectFrameworkSettings = async (command) => {
-  const settings = await detectBuildSettings(command)
-  if (settings.length === 1) {
-    return getSettingsFromDetectedSettings(settings[0])
+const getSettingsFromDetectedSettings = (settings) => {
+  if (!settings) {
+    return
   }
-
-  if (settings.length > 1) {
-    /** multiple matching detectors, make the user choose */
-    const scriptInquirerOptions = formatSettingsArrForInquirer(settings)
-    const { chosenSettings } = await inquirer.prompt({
-      name: 'chosenSettings',
-      message: `Multiple possible dev commands found`,
-      type: 'autocomplete',
-      source(/** @type {string} */ _, input = '') {
-        if (!input || input === '') {
-          return scriptInquirerOptions
-        }
-        // only show filtered results
-        return filterSettings(scriptInquirerOptions, input)
-      },
-    })
-    // TODO: do better logging here with the framework command or port
-    log(
-      `Add ${formatProperty(
-        `framework = "${chosenSettings.framework.id}"`,
-      )} to the [dev] section of your netlify.toml to avoid this selection prompt next time`,
-    )
-
-    return getSettingsFromDetectedSettings(chosenSettings)
+  return {
+    baseDirectory: settings.baseDirectory,
+    command: settings.devCommand,
+    frameworkPort: settings.frameworkPort,
+    dist: settings.dist,
+    framework: settings.framework.name,
+    env: settings.env,
+    pollingStrategies: settings.pollingStrategies,
+    plugins: getPluginsToAutoInstall(settings.plugins_from_config_file, settings.plugins_recommended),
   }
 }
 
@@ -262,26 +229,18 @@ const handleCustomFramework = ({ devConfig, workingDir }) => {
  * @param {Partial<import('./types.js').BaseServerSettings>=} config.frameworkSettings
  */
 const mergeSettings = async ({ devConfig, frameworkSettings = {}, workingDir }) => {
-  const {
-    command: frameworkCommand,
-    dist,
-    env,
-    framework,
-    frameworkPort: frameworkDetectedPort,
-    pollingStrategies = [],
-  } = frameworkSettings
-
-  const command = devConfig.command || frameworkCommand
-  const frameworkPort = devConfig.targetPort || frameworkDetectedPort
+  const command = devConfig.command || frameworkSettings.command
+  const frameworkPort = devConfig.targetPort || frameworkSettings.frameworkPort
   // if the framework doesn't start a server, we use a static one
   const useStaticServer = !(command && frameworkPort)
   return {
+    baseDirectory: devConfig.base || frameworkSettings.baseDirectory,
     command,
     frameworkPort: useStaticServer ? await getStaticServerPort({ devConfig }) : frameworkPort,
-    dist: devConfig.publish || dist || getDefaultDist(workingDir),
-    framework,
-    env,
-    pollingStrategies,
+    dist: devConfig.publish || frameworkSettings.dist || getDefaultDist(workingDir),
+    framework: frameworkSettings.framework,
+    env: frameworkSettings.env,
+    pollingStrategies: frameworkSettings.pollingStrategies || [],
     useStaticServer,
   }
 }
@@ -324,12 +283,15 @@ const detectServerSettings = async (devConfig, flags, command) => {
     // this is the default CLI behavior
 
     const runDetection = !hasCommandAndTargetPort(devConfig)
-    const frameworkSettings = runDetection ? await detectFrameworkSettings(command) : undefined
+    const frameworkSettings = runDetection
+      ? getSettingsFromDetectedSettings(await detectFrameworkSettings(command, 'dev'))
+      : undefined
     if (frameworkSettings === undefined && runDetection) {
       log(`${NETLIFYDEVWARN} No app server detected. Using simple static server`)
       settings = await handleStaticServer({ flags, devConfig, workingDir: command.workingDir })
     } else {
       validateFrameworkConfig({ devConfig })
+
       settings = await mergeSettings({ devConfig, frameworkSettings, workingDir: command.workingDir })
     }
 
@@ -371,29 +333,6 @@ const detectServerSettings = async (devConfig, flags, command) => {
   }
 }
 
-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))
-}
-
-/**
- * @param {import('@netlify/build-info').Settings[]} settings
- * @returns
- */
-const formatSettingsArrForInquirer = function (settings) {
-  return settings.map((setting) => ({
-    name: `[${chalk.yellow(setting.framework.name)}] '${setting.devCommand}'`,
-    value: { ...setting, commands: [setting.devCommand] },
-    short: `${setting.name}-${setting.devCommand}`,
-  }))
-}
-
 /**
  * Returns a copy of the provided config with any plugins provided by the
  * server settings

package/src/utils/framework-server.mjs

@@ -19,12 +19,13 @@ const FRAMEWORK_PORT_TIMEOUT = 6e5
  * Start a static server if the `useStaticServer` is provided or a framework specific server
  * @param {object} config
  * @param {import('./types.js').ServerSettings} config.settings
+ * @param {string} config.cwd
  * @returns {Promise<StartReturnObject>}
  */
-export const startFrameworkServer = async function ({ settings }) {
+export const startFrameworkServer = async function ({ cwd, settings }) {
   if (settings.useStaticServer) {
     if (settings.command) {
-      runCommand(settings.command, settings.env)
+      runCommand(settings.command, { env: settings.env, cwd })
     }
     await startStaticServer({ settings })
 
@@ -37,7 +38,7 @@ export const startFrameworkServer = async function ({ settings }) {
     text: `Waiting for framework port ${settings.frameworkPort}. This can be configured using the 'targetPort' property in the netlify.toml`,
   })
 
-  runCommand(settings.command, settings.env, spinner)
+  runCommand(settings.command, { env: settings.env, spinner, cwd })
 
   let port
   try {

package/src/utils/functions/functions.mjs

@@ -17,11 +17,7 @@ export const SERVE_FUNCTIONS_FOLDER = 'functions-serve'
  * @returns {string}
  */
 export const getFunctionsDir = ({ config, options }, defaultValue) =>
-  options.functions ||
-  (config.dev && config.dev.functions) ||
-  config.functionsDirectory ||
-  (config.dev && config.dev.Functions) ||
-  defaultValue
+  options.functions || config.dev?.functions || config.functionsDirectory || config.dev?.Functions || defaultValue
 
 export const getFunctionsManifestPath = async ({ base }) => {
   const path = resolve(base, getPathInProject(['functions', 'manifest.json']))

package/src/utils/proxy.mjs

@@ -375,7 +375,6 @@ const initializeProxy = async function ({ configPath, distDir, env, host, port,
   proxy.before('web', 'stream', (req) => {
     // See https://github.com/http-party/node-http-proxy/issues/1219#issuecomment-511110375
     if (req.headers.expect) {
-      // eslint-disable-next-line no-underscore-dangle
       req.__expectHeader = req.headers.expect
       delete req.headers.expect
     }
@@ -402,9 +401,7 @@ const initializeProxy = async function ({ configPath, distDir, env, host, port,
       handleProxyRequest(req, proxyReq)
     }
 
-    // eslint-disable-next-line no-underscore-dangle
     if (req.__expectHeader) {
-      // eslint-disable-next-line no-underscore-dangle
       proxyReq.setHeader('Expect', req.__expectHeader)
     }
     if (req.originalBody) {

package/src/utils/read-repo-url.mjs

@@ -7,6 +7,7 @@ import fetch from 'node-fetch'
 const GITHUB = 'GitHub'
 
 /**
+ * @param {string} _url
  * Takes a url like https://github.com/netlify-labs/all-the-functions/tree/master/functions/9-using-middleware
  * and returns https://api.github.com/repos/netlify-labs/all-the-functions/contents/functions/9-using-middleware
  */
@@ -36,6 +37,9 @@ const getRepoURLContents = async function (repoHost, ownerAndRepo, contentsPath)
   throw new Error('unsupported host ', repoHost)
 }
 
+/**
+ * @param {string} _url
+ */
 export const validateRepoURL = function (_url) {
   // TODO: use `url.URL()` instead
   // eslint-disable-next-line n/no-deprecated-api

package/src/utils/run-build.mjs

@@ -1,6 +1,6 @@
 // @ts-check
 import { promises as fs } from 'fs'
-import path from 'path'
+import path, { join } from 'path'
 
 import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from '../lib/edge-functions/consts.mjs'
 import { getPathInProject } from '../lib/settings.mjs'
@@ -14,12 +14,11 @@ const netlifyBuildPromise = import('@netlify/build')
 /**
  * Copies `netlify.toml`, if one is defined, into the `.netlify` internal
  * directory and returns the path to its new location.
- * @param {object} config
- * @param {string} config.configPath
- * @param {string} config.siteRoot
+ * @param {string} configPath
+ * @param {string} destinationFolder The folder where it should be copied to either the root of the repo or a package inside a monorepo
  */
-const copyConfig = async ({ configPath, siteRoot }) => {
-  const newConfigPath = path.resolve(siteRoot, getPathInProject(['netlify.toml']))
+const copyConfig = async (configPath, destinationFolder) => {
+  const newConfigPath = path.resolve(destinationFolder, getPathInProject(['netlify.toml']))
 
   try {
     await fs.copyFile(configPath, newConfigPath)
@@ -44,75 +43,51 @@ const cleanInternalDirectory = async (basePath) => {
 }
 
 /**
- *
- * @param {object} config
- * @param {string} config.projectDir
- * @param {*} config.cachedConfig
- * @param {object} config.options
- * @param {string} config.options.configPath
- * @param {*} config.options.context
- * @param {string=} config.options.cwd
- * @param {boolean} config.options.debug
- * @param {boolean} config.options.dry
- * @param {boolean} config.options.offline
- * @param {boolean} config.options.quiet
- * @param {boolean} config.options.saveConfig
+ * @param {object} params
+ * @param {import('../commands/base-command.mjs').default} params.command
+ * @param {import('../commands/base-command.mjs').default} params.command
+ * @param {*} params.options The flags of the command
+ * @param {import('./types.js').ServerSettings} params.settings
+ * @param {NodeJS.ProcessEnv} [params.env]
+ * @param {'build' | 'dev'} [params.timeline]
  * @returns
  */
-const getBuildOptions = ({
-  cachedConfig,
-  options: { configPath, context, debug, dry, offline, quiet, saveConfig },
-  projectDir,
-}) => ({
-  cachedConfig,
-  configPath,
-  siteId: cachedConfig.siteInfo.id,
-  token: cachedConfig.token,
-  dry,
-  debug,
-  context,
-  mode: 'cli',
-  telemetry: false,
-  buffer: false,
-  offline,
-  cwd: projectDir,
-  quiet,
-  saveConfig,
-})
+export const runNetlifyBuild = async ({ command, env = {}, options, settings, timeline = 'build' }) => {
+  const { cachedConfig, site } = command.netlify
 
-/**
- *
- * @param {object} config
- * @param {*} config.cachedConfig
- * @param {NodeJS.ProcessEnv} config.env
- * @param {*} config.options The flags of the command
- * @param {string} config.projectDir
- * @param {import('./types.js').ServerSettings} config.settings
- * @param {*} config.site
- * @param {'build' | 'dev'} config.timeline
- * @returns
- */
-export const runNetlifyBuild = async ({
-  cachedConfig,
-  env,
-  options,
-  projectDir,
-  settings,
-  site,
-  timeline = 'build',
-}) => {
   const { default: buildSite, startDev } = await netlifyBuildPromise
-  const sharedOptions = getBuildOptions({
-    projectDir,
+
+  const sharedOptions = {
     cachedConfig,
-    options,
-  })
+    configPath: cachedConfig.configPath,
+    siteId: cachedConfig.siteInfo.id,
+    token: cachedConfig.token,
+    dry: options.dry,
+    debug: options.debug,
+    context: options.context,
+    mode: 'cli',
+    telemetry: false,
+    buffer: false,
+    offline: options.offline,
+    cwd: cachedConfig.buildDir,
+    quiet: options.quiet,
+    saveConfig: options.saveConfig,
+  }
+
   const devCommand = async (settingsOverrides = {}) => {
+    let cwd = command.workingDir
+
+    if (command.project.workspace?.packages.length) {
+      console.log('packages', settings.baseDirectory)
+      cwd = join(command.project.jsWorkspaceRoot, settings.baseDirectory || '')
+    }
+
     const { ipVersion } = await startFrameworkServer({
       settings: {
         ...settings,
         ...settingsOverrides,
       },
+      cwd,
     })
 
     settings.frameworkHost = ipVersion === 6 ? '::1' : '127.0.0.1'
@@ -125,7 +100,7 @@ export const runNetlifyBuild = async ({
 
     // Copy `netlify.toml` into the internal directory. This will be the new
     // location of the config file for the duration of the command.
-    const tempConfigPath = await copyConfig({ configPath: cachedConfig.configPath, siteRoot: site.root })
+    const tempConfigPath = await copyConfig(cachedConfig.configPath, command.workingDir)
     const buildSiteOptions = {
       ...sharedOptions,
       outputConfigPath: tempConfigPath,

package/src/utils/shell.mjs

@@ -40,10 +40,14 @@ const cleanupBeforeExit = async ({ exitCode }) => {
 /**
  * Run a command and pipe stdout, stderr and stdin
  * @param {string} command
- * @param {NodeJS.ProcessEnv} env
+ * @param {object} options
+ * @param {import('ora').Ora|null} [options.spinner]
+ * @param {NodeJS.ProcessEnv} [options.env]
+ * @param {string} [options.cwd]
  * @returns {execa.ExecaChildProcess<string>}
  */
-export const runCommand = (command, env = {}, spinner = null) => {
+export const runCommand = (command, options = {}) => {
+  const { cwd, env = {}, spinner = null } = options
   const commandProcess = execa.command(command, {
     preferLocal: true,
     // we use reject=false to avoid rejecting synchronously when the command doesn't exist
@@ -55,6 +59,7 @@ export const runCommand = (command, env = {}, spinner = null) => {
     },
     // windowsHide needs to be false for child process to terminate properly on Windows
     windowsHide: false,
+    cwd,
   })
 
   // This ensures that an active spinner stays at the bottom of the commandline
@@ -86,8 +91,9 @@ export const runCommand = (command, env = {}, spinner = null) => {
       const [commandWithoutArgs] = command.split(' ')
       if (result.failed && isNonExistingCommandError({ command: commandWithoutArgs, error: result })) {
         log(
-          NETLIFYDEVERR,
-          `Failed running command: ${command}. Please verify ${chalk.magenta(`'${commandWithoutArgs}'`)} exists`,
+          `\n\n${NETLIFYDEVERR} Failed running command: ${command}. Please verify ${chalk.magenta(
+            `'${commandWithoutArgs}'`,
+          )} exists`,
         )
       } else {
         const errorMessage = result.failed