netlify-cli 15.8.1-rc.1 → 15.9.0

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

@@ -1,28 +1,24 @@
 // @ts-check
 import { readFile } from 'fs/promises'
 import { EOL } from 'os'
-import path, { join } from 'path'
+import path from 'path'
 import process from 'process'
 
-import { getFramework, getSettings } from '@netlify/build-info'
+import { Project } from '@netlify/build-info'
+// eslint-disable-next-line import/extensions, n/no-missing-import
+import { NodeFS } from '@netlify/build-info/node'
+import { getFramework, listFrameworks } from '@netlify/framework-info'
 import fuzzy from 'fuzzy'
 import getPort from 'get-port'
 
 import { NETLIFYDEVWARN, chalk, log } from './command-helpers.mjs'
 import { acquirePort } from './dev.mjs'
 import { getInternalFunctionsDir } from './functions/functions.mjs'
+import { reportError } from './telemetry/report-error.mjs'
 
-/** @param {string} str */
 const formatProperty = (str) => chalk.magenta(`'${str}'`)
-/** @param {string} str */
 const formatValue = (str) => chalk.green(`'${str}'`)
 
-/**
- * @param {object} options
- * @param {string} options.keyFile
- * @param {string} options.certFile
- * @returns {Promise<{ key: string, cert: string, keyFilePath: string, certFilePath: string }>}
- */
 const readHttpsSettings = async (options) => {
   if (typeof options !== 'object' || !options.keyFile || !options.certFile) {
     throw new TypeError(
@@ -55,11 +51,6 @@ const readHttpsSettings = async (options) => {
   return { key, cert, keyFilePath: path.resolve(keyFile), certFilePath: path.resolve(certFile) }
 }
 
-/**
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @param {keyof import('../commands/dev/types.js').DevConfig} config.property
- */
 const validateStringProperty = ({ devConfig, property }) => {
   if (devConfig[property] && typeof devConfig[property] !== 'string') {
     const formattedProperty = formatProperty(property)
@@ -69,11 +60,6 @@ const validateStringProperty = ({ devConfig, property }) => {
   }
 }
 
-/**
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @param {keyof import('../commands/dev/types.js').DevConfig} config.property
- */
 const validateNumberProperty = ({ devConfig, property }) => {
   if (devConfig[property] && typeof devConfig[property] !== 'number') {
     const formattedProperty = formatProperty(property)
@@ -83,11 +69,6 @@ const validateNumberProperty = ({ devConfig, property }) => {
   }
 }
 
-/**
- *
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- */
 const validateFrameworkConfig = ({ devConfig }) => {
   validateStringProperty({ devConfig, property: 'command' })
   validateNumberProperty({ devConfig, property: 'port' })
@@ -102,11 +83,6 @@ const validateFrameworkConfig = ({ devConfig }) => {
   }
 }
 
-/**
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @param {number=} config.detectedPort
- */
 const validateConfiguredPort = ({ detectedPort, devConfig }) => {
   if (devConfig.port && devConfig.port === detectedPort) {
     const formattedPort = formatProperty('port')
@@ -126,11 +102,6 @@ const getDefaultDist = () => {
   return process.cwd()
 }
 
-/**
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @returns {Promise<number>}
- */
 const getStaticServerPort = async ({ devConfig }) => {
   const port = await acquirePort({
     configuredPort: devConfig.staticServerPort,
@@ -143,10 +114,10 @@ const getStaticServerPort = async ({ devConfig }) => {
 
 /**
  *
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @param {import('commander').OptionValues} config.options
- * @param {string} config.projectDir
+ * @param {object} param0
+ * @param {import('../commands/dev/types.js').DevConfig} param0.devConfig
+ * @param {import('commander').OptionValues} param0.options
+ * @param {string} param0.projectDir
  * @returns {Promise<import('./types.js').BaseServerSettings>}
  */
 const handleStaticServer = async ({ devConfig, options, projectDir }) => {
@@ -182,84 +153,120 @@ const handleStaticServer = async ({ devConfig, options, projectDir }) => {
   }
 }
 
-// these plugins represent runtimes that are
-// expected to be "automatically" installed. Even though
-// they can be installed on package/toml, we always
-// want them installed in the site settings. When installed
-// there our build will automatically install the latest without
-// user management of the versioning.
-const pluginsToAlwaysInstall = new Set(['@netlify/plugin-nextjs'])
-
-/**
- * Retrieve a list of plugins to auto install
- * @param {string[]=} pluginsInstalled
- * @param {string[]=} pluginsRecommended
- * @returns
- */
-const getPluginsToAutoInstall = (pluginsInstalled = [], pluginsRecommended = []) =>
-  pluginsRecommended.reduce(
-    (acc, plugin) =>
-      pluginsInstalled.includes(plugin) && !pluginsToAlwaysInstall.has(plugin) ? acc : [...acc, plugin],
-    // eslint-disable-next-line no-inline-comments
-    /** @type {string[]} */ ([]),
-  )
-
 /**
  * Retrieves the settings from a framework
- * @param {import('@netlify/build-info').Settings} settings
+ * @param {import('./types.js').FrameworkInfo} framework
  * @returns {import('./types.js').BaseServerSettings}
  */
-const getSettingsFromDetectedSettings = (settings) => {
+const getSettingsFromFramework = (framework) => {
   const {
-    devCommand: command,
-    dist,
-    env,
-    framework: { name: frameworkName },
-    frameworkPort,
-    // eslint-disable-next-line camelcase
-    plugins_from_config_file,
-    // eslint-disable-next-line camelcase
-    plugins_recommended,
-    pollingStrategies,
-  } = settings
+    build: { directory: dist },
+    dev: {
+      commands: [command],
+      pollingStrategies = [],
+      port: frameworkPort,
+    },
+    env = {},
+    name: frameworkName,
+    plugins,
+    staticAssetsDirectory: staticDir,
+  } = framework
 
   return {
     command,
     frameworkPort,
-    dist,
+    dist: staticDir || dist,
     framework: frameworkName,
     env,
-    pollingStrategies,
-    plugins: getPluginsToAutoInstall(plugins_from_config_file, plugins_recommended),
+    pollingStrategies: pollingStrategies.map(({ name }) => name),
+    plugins,
   }
 }
 
+const hasDevCommand = (framework) => Array.isArray(framework.dev.commands) && framework.dev.commands.length !== 0
+
 /**
- * @param {import('@netlify/build-info').Project} project
+ * The new build setting detection with build systems and frameworks combined
+ * @param {string} projectDir
  */
-const detectFrameworkSettings = async (project) => {
-  const projectSettings = await project.getBuildSettings()
-  const settings = projectSettings
-    .filter((setting) =>
-      project.workspace && !project.workspace.isRoot
-        ? process.cwd().startsWith(join(project.jsWorkspaceRoot, setting.packagePath ?? ''))
-        : true,
+const detectSettings = async (projectDir) => {
+  const fs = new NodeFS()
+  const project = new Project(fs, projectDir)
+
+  return await project.getBuildSettings()
+}
+
+/**
+ *
+ * @param {import('./types.js').BaseServerSettings | undefined} frameworkSettings
+ * @param {import('@netlify/build-info').Settings[]} newSettings
+ * @param {Record<string, Record<string, any>>} [metadata]
+ */
+const detectChangesInNewSettings = (frameworkSettings, newSettings, metadata) => {
+  /** @type {string[]} */
+  const message = ['']
+  const [setting] = newSettings
+
+  if (frameworkSettings?.framework !== setting?.framework) {
+    message.push(
+      `- Framework does not match:`,
+      `   [old]: ${frameworkSettings?.framework}`,
+      `   [new]: ${setting?.framework}`,
+      '',
+    )
+  }
+
+  if (frameworkSettings?.command !== setting?.devCommand) {
+    message.push(
+      `- command does not match:`,
+      `   [old]: ${frameworkSettings?.command}`,
+      `   [new]: ${setting?.devCommand}`,
+      '',
+    )
+  }
+
+  if (frameworkSettings?.dist !== setting?.dist) {
+    message.push(`- dist does not match:`, `   [old]: ${frameworkSettings?.dist}`, `   [new]: ${setting?.dist}`, '')
+  }
+
+  if (frameworkSettings?.frameworkPort !== setting?.frameworkPort) {
+    message.push(
+      `- frameworkPort does not match:`,
+      `   [old]: ${frameworkSettings?.frameworkPort}`,
+      `   [new]: ${setting?.frameworkPort}`,
+      '',
+    )
+  }
+
+  if (message.length !== 0) {
+    reportError(
+      {
+        name: 'NewSettingsDetectionMismatch',
+        errorMessage: 'New Settings detection does not match old one',
+        message: message.join('\n'),
+      },
+      { severity: 'info', metadata },
     )
-    .filter((setting) => setting.devCommand)
+  }
+}
+
+const detectFrameworkSettings = async ({ projectDir }) => {
+  const projectFrameworks = await listFrameworks({ projectDir })
+  const frameworks = projectFrameworks.filter((framework) => hasDevCommand(framework))
 
-  if (settings.length === 1) {
-    return getSettingsFromDetectedSettings(settings[0])
+  if (frameworks.length === 1) {
+    return getSettingsFromFramework(frameworks[0])
   }
 
-  if (settings.length > 1) {
+  if (frameworks.length > 1) {
     // performance optimization, load inquirer on demand
     const { default: inquirer } = await import('inquirer')
     const { default: inquirerAutocompletePrompt } = await import('inquirer-autocomplete-prompt')
     /** multiple matching detectors, make the user choose */
     inquirer.registerPrompt('autocomplete', inquirerAutocompletePrompt)
-    const scriptInquirerOptions = formatSettingsArrForInquirer(settings)
-    const { chosenSettings } = await inquirer.prompt({
-      name: 'chosenSettings',
+    const scriptInquirerOptions = formatSettingsArrForInquirer(frameworks)
+    const { chosenFramework } = await inquirer.prompt({
+      name: 'chosenFramework',
       message: `Multiple possible start commands found`,
       type: 'autocomplete',
       source(_, input) {
@@ -272,24 +279,19 @@ const detectFrameworkSettings = async (project) => {
     })
     log(
       `Add ${formatProperty(
-        `framework = "${chosenSettings.framework.id}"`,
+        `framework = "${chosenFramework.id}"`,
       )} to the [dev] section of your netlify.toml to avoid this selection prompt next time`,
     )
 
-    return getSettingsFromDetectedSettings(chosenSettings)
+    return getSettingsFromFramework(chosenFramework)
   }
 }
 
-/**
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- */
 const hasCommandAndTargetPort = ({ devConfig }) => devConfig.command && devConfig.targetPort
 
 /**
  * Creates settings for the custom framework
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
+ * @param {*} param0
  * @returns {import('./types.js').BaseServerSettings}
  */
 const handleCustomFramework = ({ devConfig }) => {
@@ -309,9 +311,6 @@ const handleCustomFramework = ({ devConfig }) => {
   }
 }
 
-/**
- * @param {{ devConfig: any, frameworkSettings: import('./types.js').BaseServerSettings }} param0
- */
 const mergeSettings = async ({ devConfig, frameworkSettings = {} }) => {
   const {
     command: frameworkCommand,
@@ -339,14 +338,12 @@ const mergeSettings = async ({ devConfig, frameworkSettings = {} }) => {
 
 /**
  * Handles a forced framework and retrieves the settings for it
- * @param {{ devConfig: any, project: import('@netlify/build-info').Project }} config
+ * @param {*} param0
  * @returns {Promise<import('./types.js').BaseServerSettings>}
  */
-const handleForcedFramework = async ({ devConfig, project }) => {
+const handleForcedFramework = async ({ devConfig, projectDir }) => {
   // this throws if `devConfig.framework` is not a supported framework
-  const framework = await getFramework(devConfig.framework, project)
-  const settings = await getSettings(framework, project, '')
-  const frameworkSettings = getSettingsFromDetectedSettings(settings)
+  const frameworkSettings = getSettingsFromFramework(await getFramework(devConfig.framework, { projectDir }))
   return mergeSettings({ devConfig, frameworkSettings })
 }
 
@@ -354,12 +351,11 @@ const handleForcedFramework = async ({ devConfig, project }) => {
  * Get the server settings based on the flags and the devConfig
  * @param {import('../commands/dev/types.js').DevConfig} devConfig
  * @param {import('commander').OptionValues} options
- * @param {import('@netlify/build-info').Project} project
  * @param {string} projectDir
+ * @param {Record<string, Record<string, any>>} [metadata]
  * @returns {Promise<import('./types.js').ServerSettings>}
  */
-
-const detectServerSettings = async (devConfig, options, project, projectDir) => {
+const detectServerSettings = async (devConfig, options, projectDir, metadata) => {
   validateStringProperty({ devConfig, property: 'framework' })
 
   /** @type {Partial<import('./types.js').BaseServerSettings>} */
@@ -372,9 +368,22 @@ const detectServerSettings = async (devConfig, options, project, projectDir) =>
     // this is the default CLI behavior
 
     const runDetection = !hasCommandAndTargetPort({ devConfig })
-    const frameworkSettings = runDetection ? await detectFrameworkSettings(project) : undefined
+    const frameworkSettings = runDetection ? await detectFrameworkSettings({ projectDir }) : undefined
+    const newSettings = runDetection ? await detectSettings(projectDir) : undefined
+
+    // just report differences in the settings
+    detectChangesInNewSettings(frameworkSettings, newSettings || [], {
+      ...metadata,
+      settings: {
+        projectDir,
+        devConfig,
+        options,
+        old: frameworkSettings,
+        settings: newSettings,
+      },
+    })
 
-    if (frameworkSettings === undefined) {
+    if (frameworkSettings === undefined && runDetection) {
       log(`${NETLIFYDEVWARN} No app server detected. Using simple static server`)
       settings = await handleStaticServer({ options, devConfig, projectDir })
     } else {
@@ -390,7 +399,7 @@ const detectServerSettings = async (devConfig, options, project, projectDir) =>
   } else if (devConfig.framework) {
     validateFrameworkConfig({ devConfig })
     // this is when the user explicitly configures a framework, e.g. `framework = "gatsby"`
-    settings = await handleForcedFramework({ devConfig, project })
+    settings = await handleForcedFramework({ devConfig, projectDir })
   }
 
   validateConfiguredPort({ devConfig, detectedPort: settings.frameworkPort })
@@ -426,16 +435,15 @@ const filterSettings = function (scriptInquirerOptions, input) {
   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}`,
-  }))
+const formatSettingsArrForInquirer = function (frameworks) {
+  const formattedArr = frameworks.map((framework) =>
+    framework.dev.commands.map((command) => ({
+      name: `[${chalk.yellow(framework.name)}] '${command}'`,
+      value: { ...framework, commands: [command] },
+      short: `${framework.name}-${command}`,
+    })),
+  )
+  return formattedArr.flat()
 }
 
 /**

package/src/utils/framework-server.mjs

@@ -18,7 +18,7 @@ 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 {Partial<import('./types').ServerSettings>} config.settings
  * @returns {Promise<StartReturnObject>}
  */
 export const startFrameworkServer = async function ({ settings }) {
@@ -46,7 +46,7 @@ export const startFrameworkServer = async function ({ settings }) {
       host: 'localhost',
       output: 'silent',
       timeout: FRAMEWORK_PORT_TIMEOUT,
-      ...(settings.pollingStrategies?.includes('HTTP') && { protocol: 'http' }),
+      ...(settings.pollingStrategies.includes('HTTP') && { protocol: 'http' }),
     })
 
     if (!port.open) {

package/src/utils/init/config-github.mjs

@@ -207,7 +207,7 @@ export const configGithub = async ({ command, repoName, repoOwner, siteId }) =>
   const { netlify } = command
   const {
     api,
-    cachedConfig: { configPath },
+    cachedConfig: { configPath, env },
     config,
     globalConfig,
     repositoryRoot,
@@ -220,7 +220,7 @@ export const configGithub = async ({ command, repoName, repoOwner, siteId }) =>
     repositoryRoot,
     siteRoot,
     config,
-    project: command.project,
+    env,
   })
   await saveNetlifyToml({ repositoryRoot, config, configPath, baseDir, buildCmd, buildDir, functionsDir })
 

package/src/utils/init/config-manual.mjs

@@ -5,12 +5,7 @@ import { exit, log } from '../command-helpers.mjs'
 
 import { createDeployKey, getBuildSettings, saveNetlifyToml, setupSite } from './utils.mjs'
 
-/**
- * Prompts for granting the netlify ssh public key access to your repo
- * @param {object} deployKey
- * @param {string} deployKey.public_key
- */
-const addDeployKey = async (deployKey) => {
+const addDeployKey = async ({ deployKey }) => {
   log('\nGive this Netlify SSH public key access to your repository:\n')
   log(`\n${deployKey.public_key}\n\n`)
 
@@ -28,11 +23,6 @@ const addDeployKey = async (deployKey) => {
   }
 }
 
-/**
- * @param {object} config
- * @param {Awaited<ReturnType<import('../../utils/get-repo-data.mjs').default>>} config.repoData
- * @returns {Promise<string>}
- */
 const getRepoPath = async ({ repoData }) => {
   const { repoPath } = await inquirer.prompt([
     {
@@ -40,9 +30,6 @@ const getRepoPath = async ({ repoData }) => {
       name: 'repoPath',
       message: 'The SSH URL of the remote git repo:',
       default: repoData.url,
-      /**
-       * @param {string} url
-       */
       validate: (url) => SSH_URL_REGEXP.test(url) || 'The URL provided does not use the SSH protocol',
     },
   ])
@@ -50,11 +37,7 @@ const getRepoPath = async ({ repoData }) => {
   return repoPath
 }
 
-/**
- * @param {string} deployHook
- * @returns
- */
-const addDeployHook = async (deployHook) => {
+const addDeployHook = async ({ deployHook }) => {
   log('\nConfigure the following webhook for your repository:\n')
   log(`\n${deployHook}\n\n`)
   const { deployHookAdded } = await inquirer.prompt([
@@ -72,14 +55,14 @@ const addDeployHook = async (deployHook) => {
 /**
  * @param {object} config
  * @param {import('../../commands/base-command.mjs').default} config.command
- * @param {Awaited<ReturnType<import('../../utils/get-repo-data.mjs').default>>} config.repoData
+ * @param {*} config.repoData
  * @param {string} config.siteId
  */
 export default async function configManual({ command, repoData, siteId }) {
   const { netlify } = command
   const {
     api,
-    cachedConfig: { configPath },
+    cachedConfig: { configPath, env },
     config,
     repositoryRoot,
     site: { root: siteRoot },
@@ -89,12 +72,12 @@ export default async function configManual({ command, repoData, siteId }) {
     repositoryRoot,
     siteRoot,
     config,
-    project: command.project,
+    env,
   })
   await saveNetlifyToml({ repositoryRoot, config, configPath, baseDir, buildCmd, buildDir, functionsDir })
 
   const deployKey = await createDeployKey({ api })
-  await addDeployKey(deployKey)
+  await addDeployKey({ deployKey })
 
   const repoPath = await getRepoPath({ repoData })
   const repo = {
@@ -116,7 +99,7 @@ export default async function configManual({ command, repoData, siteId }) {
     configPlugins: config.plugins,
     pluginsToInstall,
   })
-  const deployHookAdded = await addDeployHook(updatedSite.deploy_hook)
+  const deployHookAdded = await addDeployHook({ deployHook: updatedSite.deploy_hook })
   if (!deployHookAdded) {
     exit()
   }

package/src/utils/init/frameworks.mjs

@@ -1,18 +1,22 @@
 // @ts-check
+import { listFrameworks } from '@netlify/framework-info'
 
-/**
- * @param {{ project: import("@netlify/build-info").Project }} param0
- * @returns
- */
-export const getFrameworkInfo = async ({ project }) => {
-  const settings = await project.getBuildSettings()
+export const getFrameworkInfo = async ({ baseDirectory, nodeVersion }) => {
+  const frameworks = await listFrameworks({ projectDir: baseDirectory, nodeVersion })
   // several frameworks can be detected - first one has highest priority
-  if (settings?.length) {
+  if (frameworks.length !== 0) {
+    const [
+      {
+        build: { commands, directory },
+        name,
+        plugins,
+      },
+    ] = frameworks
     return {
-      frameworkName: settings[0].framework?.name,
-      frameworkBuildCommand: settings[0].buildCommand,
-      frameworkBuildDir: settings[0].dist,
-      frameworkPlugins: settings[0].plugins_recommended,
+      frameworkName: name,
+      frameworkBuildCommand: commands[0],
+      frameworkBuildDir: directory,
+      frameworkPlugins: plugins,
     }
   }
   return {}

package/src/utils/init/utils.mjs

@@ -11,6 +11,7 @@ import { normalizeBackslash } from '../../lib/path.mjs'
 import { chalk, error as failAndExit, log, warn } from '../command-helpers.mjs'
 
 import { getFrameworkInfo } from './frameworks.mjs'
+import { detectNodeVersion } from './node-version.mjs'
 import { getRecommendPlugins, getUIPlugins } from './plugins.mjs'
 
 const normalizeDir = ({ baseDirectory, defaultValue, dir }) => {
@@ -82,19 +83,17 @@ const getPromptInputs = ({ defaultBaseDir, defaultBuildCmd, defaultBuildDir }) =
 const getBaseDirectory = ({ repositoryRoot, siteRoot }) =>
   path.normalize(repositoryRoot) === path.normalize(siteRoot) ? process.cwd() : siteRoot
 
-/**
- * @param {{ config: any, repositoryRoot: any, siteRoot: any, project: import("@netlify/build-info").Project }} param0
- * @returns
- */
-export const getBuildSettings = async ({ config, project, repositoryRoot, siteRoot }) => {
+export const getBuildSettings = async ({ config, env, repositoryRoot, siteRoot }) => {
   const baseDirectory = getBaseDirectory({ repositoryRoot, siteRoot })
+  const nodeVersion = await detectNodeVersion({ baseDirectory, env })
   const {
     frameworkBuildCommand,
     frameworkBuildDir,
     frameworkName,
     frameworkPlugins = [],
   } = await getFrameworkInfo({
-    project,
+    baseDirectory,
+    nodeVersion,
   })
   const { defaultBaseDir, defaultBuildCmd, defaultBuildDir, defaultFunctionsDir, recommendedPlugins } =
     await getDefaultSettings({

package/src/utils/proxy.mjs

@@ -599,10 +599,6 @@ const onRequest = async (
   proxy.web(req, res, options)
 }
 
-/**
- * @param {import('./types.js').ServerSettings} settings
- * @returns
- */
 export const getProxyUrl = function (settings) {
   const scheme = settings.https ? 'https' : 'http'
   return `${scheme}://localhost:${settings.port}`