netlify-cli 15.7.0 → 15.8.1-rc.0

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

@@ -1,24 +1,28 @@
 // @ts-check
 import { readFile } from 'fs/promises'
 import { EOL } from 'os'
-import path from 'path'
+import path, { join } from 'path'
 import process from 'process'
 
-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 { getFramework, getSettings } from '@netlify/build-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(
@@ -51,6 +55,11 @@ 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)
@@ -60,6 +69,11 @@ 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)
@@ -69,6 +83,11 @@ 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' })
@@ -83,6 +102,11 @@ 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')
@@ -102,6 +126,11 @@ 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,
@@ -114,10 +143,10 @@ const getStaticServerPort = async ({ devConfig }) => {
 
 /**
  *
- * @param {object} param0
- * @param {import('../commands/dev/types.js').DevConfig} param0.devConfig
- * @param {import('commander').OptionValues} param0.options
- * @param {string} param0.projectDir
+ * @param {object} config
+ * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
+ * @param {import('commander').OptionValues} config.options
+ * @param {string} config.projectDir
  * @returns {Promise<import('./types.js').BaseServerSettings>}
  */
 const handleStaticServer = async ({ devConfig, options, projectDir }) => {
@@ -153,120 +182,84 @@ 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('./types.js').FrameworkInfo} framework
+ * @param {import('@netlify/build-info').Settings} settings
  * @returns {import('./types.js').BaseServerSettings}
  */
-const getSettingsFromFramework = (framework) => {
+const getSettingsFromDetectedSettings = (settings) => {
   const {
-    build: { directory: dist },
-    dev: {
-      commands: [command],
-      pollingStrategies = [],
-      port: frameworkPort,
-    },
-    env = {},
-    name: frameworkName,
-    plugins,
-    staticAssetsDirectory: staticDir,
-  } = framework
+    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
 
   return {
     command,
     frameworkPort,
-    dist: staticDir || dist,
+    dist,
     framework: frameworkName,
     env,
-    pollingStrategies: pollingStrategies.map(({ name }) => name),
-    plugins,
+    pollingStrategies,
+    plugins: getPluginsToAutoInstall(plugins_from_config_file, plugins_recommended),
   }
 }
 
-const hasDevCommand = (framework) => Array.isArray(framework.dev.commands) && framework.dev.commands.length !== 0
-
 /**
- * The new build setting detection with build systems and frameworks combined
- * @param {string} projectDir
+ * @param {import('@netlify/build-info').Project} project
  */
-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 },
+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 detectFrameworkSettings = async ({ projectDir }) => {
-  const projectFrameworks = await listFrameworks({ projectDir })
-  const frameworks = projectFrameworks.filter((framework) => hasDevCommand(framework))
+    .filter((setting) => setting.devCommand)
 
-  if (frameworks.length === 1) {
-    return getSettingsFromFramework(frameworks[0])
+  if (settings.length === 1) {
+    return getSettingsFromDetectedSettings(settings[0])
   }
 
-  if (frameworks.length > 1) {
+  if (settings.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(frameworks)
-    const { chosenFramework } = await inquirer.prompt({
-      name: 'chosenFramework',
+    const scriptInquirerOptions = formatSettingsArrForInquirer(settings)
+    const { chosenSettings } = await inquirer.prompt({
+      name: 'chosenSettings',
       message: `Multiple possible start commands found`,
       type: 'autocomplete',
       source(_, input) {
@@ -279,19 +272,24 @@ const detectFrameworkSettings = async ({ projectDir }) => {
     })
     log(
       `Add ${formatProperty(
-        `framework = "${chosenFramework.id}"`,
+        `framework = "${chosenSettings.framework.id}"`,
       )} to the [dev] section of your netlify.toml to avoid this selection prompt next time`,
     )
 
-    return getSettingsFromFramework(chosenFramework)
+    return getSettingsFromDetectedSettings(chosenSettings)
   }
 }
 
+/**
+ * @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 {*} param0
+ * @param {object} config
+ * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
  * @returns {import('./types.js').BaseServerSettings}
  */
 const handleCustomFramework = ({ devConfig }) => {
@@ -311,6 +309,9 @@ const handleCustomFramework = ({ devConfig }) => {
   }
 }
 
+/**
+ * @param {{ devConfig: any, frameworkSettings: import('./types.js').BaseServerSettings }} param0
+ */
 const mergeSettings = async ({ devConfig, frameworkSettings = {} }) => {
   const {
     command: frameworkCommand,
@@ -338,12 +339,14 @@ const mergeSettings = async ({ devConfig, frameworkSettings = {} }) => {
 
 /**
  * Handles a forced framework and retrieves the settings for it
- * @param {*} param0
+ * @param {{ devConfig: any, project: import('@netlify/build-info').Project }} config
  * @returns {Promise<import('./types.js').BaseServerSettings>}
  */
-const handleForcedFramework = async ({ devConfig, projectDir }) => {
+const handleForcedFramework = async ({ devConfig, project }) => {
   // this throws if `devConfig.framework` is not a supported framework
-  const frameworkSettings = getSettingsFromFramework(await getFramework(devConfig.framework, { projectDir }))
+  const framework = await getFramework(devConfig.framework, project)
+  const settings = await getSettings(framework, project, '')
+  const frameworkSettings = getSettingsFromDetectedSettings(settings)
   return mergeSettings({ devConfig, frameworkSettings })
 }
 
@@ -351,11 +354,12 @@ const handleForcedFramework = async ({ devConfig, projectDir }) => {
  * 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, projectDir, metadata) => {
+
+const detectServerSettings = async (devConfig, options, project, projectDir) => {
   validateStringProperty({ devConfig, property: 'framework' })
 
   /** @type {Partial<import('./types.js').BaseServerSettings>} */
@@ -368,22 +372,9 @@ const detectServerSettings = async (devConfig, options, projectDir, metadata) =>
     // this is the default CLI behavior
 
     const runDetection = !hasCommandAndTargetPort({ devConfig })
-    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,
-      },
-    })
+    const frameworkSettings = runDetection ? await detectFrameworkSettings(project) : undefined
 
-    if (frameworkSettings === undefined && runDetection) {
+    if (frameworkSettings === undefined) {
       log(`${NETLIFYDEVWARN} No app server detected. Using simple static server`)
       settings = await handleStaticServer({ options, devConfig, projectDir })
     } else {
@@ -399,7 +390,7 @@ const detectServerSettings = async (devConfig, options, projectDir, metadata) =>
   } else if (devConfig.framework) {
     validateFrameworkConfig({ devConfig })
     // this is when the user explicitly configures a framework, e.g. `framework = "gatsby"`
-    settings = await handleForcedFramework({ devConfig, projectDir })
+    settings = await handleForcedFramework({ devConfig, project })
   }
 
   validateConfiguredPort({ devConfig, detectedPort: settings.frameworkPort })
@@ -435,15 +426,16 @@ const filterSettings = function (scriptInquirerOptions, input) {
   return scriptInquirerOptions.filter((t) => filteredSettingNames.has(t.name))
 }
 
-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()
+/**
+ * @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}`,
+  }))
 }
 
 /**

package/src/utils/dev.mjs

@@ -107,6 +107,7 @@ export const getSiteInformation = async ({ api, offline, site, siteInfo }) => {
     return {
       addonsUrls,
       siteUrl: siteInfo.ssl_url,
+      accountId: account.id,
       capabilities: {
         backgroundFunctions: supportsBackgroundFunctions(account),
       },

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 {Partial<import('./types').ServerSettings>} config.settings
+ * @param {import('./types.js').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, env },
+    cachedConfig: { configPath },
     config,
     globalConfig,
     repositoryRoot,
@@ -220,7 +220,7 @@ export const configGithub = async ({ command, repoName, repoOwner, siteId }) =>
     repositoryRoot,
     siteRoot,
     config,
-    env,
+    project: command.project,
   })
   await saveNetlifyToml({ repositoryRoot, config, configPath, baseDir, buildCmd, buildDir, functionsDir })
 

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

@@ -62,7 +62,7 @@ export default async function configManual({ command, repoData, siteId }) {
   const { netlify } = command
   const {
     api,
-    cachedConfig: { configPath, env },
+    cachedConfig: { configPath },
     config,
     repositoryRoot,
     site: { root: siteRoot },
@@ -72,7 +72,7 @@ export default async function configManual({ command, repoData, siteId }) {
     repositoryRoot,
     siteRoot,
     config,
-    env,
+    project: command.project,
   })
   await saveNetlifyToml({ repositoryRoot, config, configPath, baseDir, buildCmd, buildDir, functionsDir })
 

package/src/utils/init/frameworks.mjs

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

package/src/utils/init/utils.mjs

@@ -11,7 +11,6 @@ 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 }) => {
@@ -83,17 +82,19 @@ const getPromptInputs = ({ defaultBaseDir, defaultBuildCmd, defaultBuildDir }) =
 const getBaseDirectory = ({ repositoryRoot, siteRoot }) =>
   path.normalize(repositoryRoot) === path.normalize(siteRoot) ? process.cwd() : siteRoot
 
-export const getBuildSettings = async ({ config, env, repositoryRoot, siteRoot }) => {
+/**
+ * @param {{ config: any, repositoryRoot: any, siteRoot: any, project: import("@netlify/build-info").Project }} param0
+ * @returns
+ */
+export const getBuildSettings = async ({ config, project, repositoryRoot, siteRoot }) => {
   const baseDirectory = getBaseDirectory({ repositoryRoot, siteRoot })
-  const nodeVersion = await detectNodeVersion({ baseDirectory, env })
   const {
     frameworkBuildCommand,
     frameworkBuildDir,
     frameworkName,
     frameworkPlugins = [],
   } = await getFrameworkInfo({
-    baseDirectory,
-    nodeVersion,
+    project,
   })
   const { defaultBaseDir, defaultBuildCmd, defaultBuildDir, defaultFunctionsDir, recommendedPlugins } =
     await getDefaultSettings({

package/src/utils/proxy-server.mjs

@@ -53,6 +53,7 @@ export const generateInspectSettings = (edgeInspect, edgeInspectBrk) => {
  * @returns
  */
 export const startProxyServer = async ({
+  accountId,
   addonsUrls,
   config,
   configPath,
@@ -83,6 +84,7 @@ export const startProxyServer = async ({
     settings,
     state,
     siteInfo,
+    accountId,
   })
   if (!url) {
     log(NETLIFYDEVERR, `Unable to start proxy server on port '${settings.port}'`)

package/src/utils/proxy.mjs

@@ -36,9 +36,29 @@ import { generateRequestID } from './request-id.mjs'
 import { createRewriter, onChanges } from './rules-proxy.mjs'
 import { signRedirect } from './sign-redirect.mjs'
 
-const decompress = util.promisify(zlib.gunzip)
+const gunzip = util.promisify(zlib.gunzip)
+const brotliDecompress = util.promisify(zlib.brotliDecompress)
+const deflate = util.promisify(zlib.deflate)
 const shouldGenerateETag = Symbol('Internal: response should generate ETag')
 
+/**
+ * @param {Buffer} body
+ * @param {string | undefined} contentEncoding
+ * @returns {Promise<Buffer>}
+ */
+const decompressResponseBody = async function (body, contentEncoding = '') {
+  switch (contentEncoding) {
+    case 'gzip':
+      return await gunzip(body)
+    case 'br':
+      return await brotliDecompress(body)
+    case 'deflate':
+      return await deflate(body)
+    default:
+      return body
+  }
+}
+
 const formatEdgeFunctionError = (errorBuffer, acceptsHtml) => {
   const {
     error: { message, name, stack },
@@ -479,7 +499,7 @@ const initializeProxy = async function ({ configPath, distDir, env, host, port,
 
       if (isEdgeFunctionsRequest(req) && isUncaughtError) {
         const acceptsHtml = req.headers && req.headers.accept && req.headers.accept.includes('text/html')
-        const decompressedBody = await decompress(responseBody)
+        const decompressedBody = await decompressResponseBody(responseBody, req.headers['content-encoding'])
         const formattedBody = formatEdgeFunctionError(decompressedBody, acceptsHtml)
         const errorResponse = acceptsHtml
           ? await renderErrorTemplate(formattedBody, './templates/function-error.html', 'edge function')
@@ -487,6 +507,7 @@ const initializeProxy = async function ({ configPath, distDir, env, host, port,
         const contentLength = Buffer.from(errorResponse, 'utf8').byteLength
 
         res.setHeader('content-length', contentLength)
+        res.statusCode = 500
         res.write(errorResponse)
         return res.end()
       }
@@ -578,12 +599,17 @@ 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}`
 }
 
 export const startProxy = async function ({
+  accountId,
   addonsUrls,
   config,
   configPath,
@@ -615,6 +641,7 @@ export const startProxy = async function ({
     passthroughPort: secondaryServerPort || settings.port,
     projectDir,
     siteInfo,
+    accountId,
     state,
   })
   const proxy = await initializeProxy({